Project SkyFire Core
SkyFire 5.4.8 server core API documentation
Loading...
Searching...
No Matches
PlayerStorage.cpp
Go to the documentation of this file.
1/*
2* This file is part of Project SkyFire https://www.projectskyfire.org.
3* See LICENSE.md file for Copyright information
4*/
5
6#include "Player.h"
7#include "Bag.h"
8#include "Battleground.h"
9#include "BattlegroundMgr.h"
10#include "DatabaseEnv.h"
11#include "DB2Stores.h"
12#include "GameEventMgr.h"
13#include "Group.h"
14#include "Item.h"
15#include "ItemPrototype.h"
16#include "LFGMgr.h"
17#include "Log.h"
18#include "Map.h"
19#include "ObjectMgr.h"
20#include "SpellInfo.h"
21#include "SpellMgr.h"
22#include "UpdateData.h"
23#include "World.h"
24#include "WorldPacket.h"
25#include "WorldSession.h"
26
27uint32 Player::GetItemCount(uint32 item, bool inBankAlso, Item* skipItem) const
28{
29 uint32 count = 0;
30 for (uint8 i = EQUIPMENT_SLOT_START; i < INVENTORY_SLOT_ITEM_END; i++)
31 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
32 if (pItem != skipItem && pItem->GetEntry() == item)
33 count += pItem->GetCount();
34
35 for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; ++i)
36 if (Bag* pBag = GetBagByPos(i))
37 count += pBag->GetItemCount(item, skipItem);
38
39 if (skipItem && skipItem->GetTemplate()->GemProperties)
40 for (uint8 i = EQUIPMENT_SLOT_START; i < INVENTORY_SLOT_ITEM_END; ++i)
41 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
42 if (pItem != skipItem && pItem->GetTemplate()->Socket[0].Color)
43 count += pItem->GetGemCountWithID(item);
44
45 if (inBankAlso)
46 {
47 // checking every item from 39 to 74 (including bank bags)
48 for (uint8 i = BANK_SLOT_ITEM_START; i < BANK_SLOT_BAG_END; ++i)
49 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
50 if (pItem != skipItem && pItem->GetEntry() == item)
51 count += pItem->GetCount();
52
53 for (uint8 i = BANK_SLOT_BAG_START; i < BANK_SLOT_BAG_END; ++i)
54 if (Bag* pBag = GetBagByPos(i))
55 count += pBag->GetItemCount(item, skipItem);
56
57 if (skipItem && skipItem->GetTemplate()->GemProperties)
58 for (uint8 i = BANK_SLOT_ITEM_START; i < BANK_SLOT_ITEM_END; ++i)
59 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
60 if (pItem != skipItem && pItem->GetTemplate()->Socket[0].Color)
61 count += pItem->GetGemCountWithID(item);
62 }
63
64 return count;
65}
66
67uint32 Player::GetItemCountWithLimitCategory(uint32 limitCategory, Item* skipItem) const
68{
69 uint32 count = 0;
70 for (int i = EQUIPMENT_SLOT_START; i < INVENTORY_SLOT_ITEM_END; ++i)
71 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
72 if (pItem != skipItem)
73 if (ItemTemplate const* pProto = pItem->GetTemplate())
74 if (pProto->ItemLimitCategory == limitCategory)
75 count += pItem->GetCount();
76
77 for (int i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; ++i)
78 if (Bag* pBag = GetBagByPos(i))
79 count += pBag->GetItemCountWithLimitCategory(limitCategory, skipItem);
80
81 for (int i = BANK_SLOT_ITEM_START; i < BANK_SLOT_BAG_END; ++i)
82 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
83 if (pItem != skipItem)
84 if (ItemTemplate const* pProto = pItem->GetTemplate())
85 if (pProto->ItemLimitCategory == limitCategory)
86 count += pItem->GetCount();
87
88 for (int i = BANK_SLOT_BAG_START; i < BANK_SLOT_BAG_END; ++i)
89 if (Bag* pBag = GetBagByPos(i))
90 count += pBag->GetItemCountWithLimitCategory(limitCategory, skipItem);
91
92 return count;
93}
94
95Item* Player::GetItemByGuid(uint64 guid) const
96{
97 for (uint8 i = EQUIPMENT_SLOT_START; i < INVENTORY_SLOT_ITEM_END; ++i)
98 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
99 if (pItem->GetGUID() == guid)
100 return pItem;
101
102 for (int i = BANK_SLOT_ITEM_START; i < BANK_SLOT_BAG_END; ++i)
103 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
104 if (pItem->GetGUID() == guid)
105 return pItem;
106
107 for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; ++i)
108 if (Bag* pBag = GetBagByPos(i))
109 for (uint32 j = 0; j < pBag->GetBagSize(); ++j)
110 if (Item* pItem = pBag->GetItemByPos(j))
111 if (pItem->GetGUID() == guid)
112 return pItem;
113
114 for (uint8 i = BANK_SLOT_BAG_START; i < BANK_SLOT_BAG_END; ++i)
115 if (Bag* pBag = GetBagByPos(i))
116 for (uint32 j = 0; j < pBag->GetBagSize(); ++j)
117 if (Item* pItem = pBag->GetItemByPos(j))
118 if (pItem->GetGUID() == guid)
119 return pItem;
120
121 return NULL;
122}
123
124Item* Player::GetItemByPos(uint16 pos) const
125{
126 uint8 bag = pos >> 8;
127 uint8 slot = pos & 255;
128 return GetItemByPos(bag, slot);
129}
130
131Item* Player::GetItemByPos(uint8 bag, uint8 slot) const
132{
133 if (bag == INVENTORY_SLOT_BAG_0 && slot < BANK_SLOT_BAG_END)
134 return m_items[slot];
135 else if (Bag* pBag = GetBagByPos(bag))
136 return pBag->GetItemByPos(slot);
137 return NULL;
138}
139
140//Does additional check for disarmed weapons
141Item* Player::GetUseableItemByPos(uint8 bag, uint8 slot) const
142{
143 if (!CanUseAttackType(GetAttackBySlot(slot)))
144 return NULL;
145 return GetItemByPos(bag, slot);
146}
147
148Bag* Player::GetBagByPos(uint8 bag) const
149{
150 if ((bag >= INVENTORY_SLOT_BAG_START && bag < INVENTORY_SLOT_BAG_END)
151 || (bag >= BANK_SLOT_BAG_START && bag < BANK_SLOT_BAG_END))
152 if (Item* item = GetItemByPos(INVENTORY_SLOT_BAG_0, bag))
153 return item->ToBag();
154 return NULL;
155}
156
157Item* Player::GetWeaponForAttack(WeaponAttackType attackType, bool useable /*= false*/) const
158{
159 uint8 slot;
160 switch (attackType)
161 {
162 case WeaponAttackType::RANGED_ATTACK:
163 case WeaponAttackType::BASE_ATTACK:
164 slot = EQUIPMENT_SLOT_MAINHAND;
165 break;
166 case WeaponAttackType::OFF_ATTACK:
167 slot = EQUIPMENT_SLOT_OFFHAND;
168 break;
169
170 default: return NULL;
171 }
172
173 Item* item = NULL;
174 if (useable)
175 item = GetUseableItemByPos(INVENTORY_SLOT_BAG_0, slot);
176 else
177 item = GetItemByPos(INVENTORY_SLOT_BAG_0, slot);
178 if (!item || item->GetTemplate()->Class != ITEM_CLASS_WEAPON)
179 return NULL;
180
181 if (!useable)
182 return item;
183
184 if (item->IsBroken() || IsInFeralForm())
185 return NULL;
186
187 return item;
188}
189
190Item* Player::GetShield(bool useable) const
191{
192 Item* item = NULL;
193 if (useable)
194 item = GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
195 else
196 item = GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
197 if (!item || item->GetTemplate()->Class != ITEM_CLASS_ARMOR)
198 return NULL;
199
200 if (!useable)
201 return item;
202
203 if (item->IsBroken())
204 return NULL;
205
206 return item;
207}
208
218
219bool Player::IsInventoryPos(uint8 bag, uint8 slot)
220{
221 if (bag == INVENTORY_SLOT_BAG_0 && slot == NULL_SLOT)
222 return true;
223 if (bag == INVENTORY_SLOT_BAG_0 && (slot >= INVENTORY_SLOT_ITEM_START && slot < INVENTORY_SLOT_ITEM_END))
224 return true;
225 if (bag >= INVENTORY_SLOT_BAG_START && bag < INVENTORY_SLOT_BAG_END)
226 return true;
227 return false;
228}
229
230bool Player::IsEquipmentPos(uint8 bag, uint8 slot)
231{
232 if (bag == INVENTORY_SLOT_BAG_0 && (slot < EQUIPMENT_SLOT_END))
233 return true;
234 if (bag == INVENTORY_SLOT_BAG_0 && (slot >= INVENTORY_SLOT_BAG_START && slot < INVENTORY_SLOT_BAG_END))
235 return true;
236 return false;
237}
238
239bool Player::IsBankPos(uint8 bag, uint8 slot)
240{
241 if (bag == INVENTORY_SLOT_BAG_0 && (slot >= BANK_SLOT_ITEM_START && slot < BANK_SLOT_ITEM_END))
242 return true;
243 if (bag == INVENTORY_SLOT_BAG_0 && (slot >= BANK_SLOT_BAG_START && slot < BANK_SLOT_BAG_END))
244 return true;
245 if (bag >= BANK_SLOT_BAG_START && bag < BANK_SLOT_BAG_END)
246 return true;
247 return false;
248}
249
250bool Player::IsBagPos(uint16 pos)
251{
252 uint8 bag = pos >> 8;
253 uint8 slot = pos & 255;
254 if (bag == INVENTORY_SLOT_BAG_0 && (slot >= INVENTORY_SLOT_BAG_START && slot < INVENTORY_SLOT_BAG_END))
255 return true;
256 if (bag == INVENTORY_SLOT_BAG_0 && (slot >= BANK_SLOT_BAG_START && slot < BANK_SLOT_BAG_END))
257 return true;
258 return false;
259}
260
261bool Player::IsValidPos(uint8 bag, uint8 slot, bool explicit_pos)
262{
263 // post selected
264 if (bag == NULL_BAG && !explicit_pos)
265 return true;
266
267 if (bag == INVENTORY_SLOT_BAG_0)
268 {
269 // any post selected
270 if (slot == NULL_SLOT && !explicit_pos)
271 return true;
272
273 // equipment
274 if (slot < EQUIPMENT_SLOT_END)
275 return true;
276
277 // bag equip slots
278 if (slot >= INVENTORY_SLOT_BAG_START && slot < INVENTORY_SLOT_BAG_END)
279 return true;
280
281 // backpack slots
282 if (slot >= INVENTORY_SLOT_ITEM_START && slot < INVENTORY_SLOT_ITEM_END)
283 return true;
284
285 // bank main slots
286 if (slot >= BANK_SLOT_ITEM_START && slot < BANK_SLOT_ITEM_END)
287 return true;
288
289 // bank bag slots
290 if (slot >= BANK_SLOT_BAG_START && slot < BANK_SLOT_BAG_END)
291 return true;
292
293 return false;
294 }
295
296 // bag content slots
297 // bank bag content slots
298 if (Bag* pBag = GetBagByPos(bag))
299 {
300 // any post selected
301 if (slot == NULL_SLOT && !explicit_pos)
302 return true;
303
304 return slot < pBag->GetBagSize();
305 }
306
307 // where this?
308 return false;
309}
310
311bool Player::HasItemCount(uint32 item, uint32 count, bool inBankAlso) const
312{
313 uint32 tempcount = 0;
314 for (uint8 i = EQUIPMENT_SLOT_START; i < INVENTORY_SLOT_ITEM_END; i++)
315 {
316 Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i);
317 if (pItem && pItem->GetEntry() == item && !pItem->IsInTrade())
318 {
319 tempcount += pItem->GetCount();
320 if (tempcount >= count)
321 return true;
322 }
323 }
324
325 for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
326 {
327 if (Bag* pBag = GetBagByPos(i))
328 {
329 for (uint32 j = 0; j < pBag->GetBagSize(); j++)
330 {
331 Item* pItem = GetItemByPos(i, j);
332 if (pItem && pItem->GetEntry() == item && !pItem->IsInTrade())
333 {
334 tempcount += pItem->GetCount();
335 if (tempcount >= count)
336 return true;
337 }
338 }
339 }
340 }
341
342 if (inBankAlso)
343 {
344 for (uint8 i = BANK_SLOT_ITEM_START; i < BANK_SLOT_ITEM_END; i++)
345 {
346 Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i);
347 if (pItem && pItem->GetEntry() == item && !pItem->IsInTrade())
348 {
349 tempcount += pItem->GetCount();
350 if (tempcount >= count)
351 return true;
352 }
353 }
354 for (uint8 i = BANK_SLOT_BAG_START; i < BANK_SLOT_BAG_END; i++)
355 {
356 if (Bag* pBag = GetBagByPos(i))
357 {
358 for (uint32 j = 0; j < pBag->GetBagSize(); j++)
359 {
360 Item* pItem = GetItemByPos(i, j);
361 if (pItem && pItem->GetEntry() == item && !pItem->IsInTrade())
362 {
363 tempcount += pItem->GetCount();
364 if (tempcount >= count)
365 return true;
366 }
367 }
368 }
369 }
370 }
371
372 return false;
373}
374
375bool Player::HasItemOrGemWithIdEquipped(uint32 item, uint32 count, uint8 except_slot) const
376{
377 uint32 tempcount = 0;
378 for (uint8 i = EQUIPMENT_SLOT_START; i < EQUIPMENT_SLOT_END; ++i)
379 {
380 if (i == except_slot)
381 continue;
382
383 Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i);
384 if (pItem && pItem->GetEntry() == item)
385 {
386 tempcount += pItem->GetCount();
387 if (tempcount >= count)
388 return true;
389 }
390 }
391
392 ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(item);
393 if (pProto && pProto->GemProperties)
394 {
395 for (uint8 i = EQUIPMENT_SLOT_START; i < EQUIPMENT_SLOT_END; ++i)
396 {
397 if (i == except_slot)
398 continue;
399
400 Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i);
401 if (pItem && pItem->GetTemplate()->Socket[0].Color)
402 {
403 tempcount += pItem->GetGemCountWithID(item);
404 if (tempcount >= count)
405 return true;
406 }
407 }
408 }
409
410 return false;
411}
412
413bool Player::HasItemOrGemWithLimitCategoryEquipped(uint32 limitCategory, uint32 count, uint8 except_slot) const
414{
415 uint32 tempcount = 0;
416 for (uint8 i = EQUIPMENT_SLOT_START; i < EQUIPMENT_SLOT_END; ++i)
417 {
418 if (i == except_slot)
419 continue;
420
421 Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i);
422 if (!pItem)
423 continue;
424
425 ItemTemplate const* pProto = pItem->GetTemplate();
426 if (!pProto)
427 continue;
428
429 if (pProto->ItemLimitCategory == limitCategory)
430 {
431 tempcount += pItem->GetCount();
432 if (tempcount >= count)
433 return true;
434 }
435
436 if (pProto->Socket[0].Color || pItem->GetEnchantmentId(PRISMATIC_ENCHANTMENT_SLOT))
437 {
438 tempcount += pItem->GetGemCountWithLimitCategory(limitCategory);
439 if (tempcount >= count)
440 return true;
441 }
442 }
443
444 return false;
445}
446
447InventoryResult Player::CanTakeMoreSimilarItems(uint32 entry, uint32 count, Item* pItem, uint32* no_space_count) const
448{
449 ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(entry);
450 if (!pProto)
451 {
452 if (no_space_count)
453 *no_space_count = count;
454 return EQUIP_ERR_ITEM_MAX_COUNT;
455 }
456
457 if (pItem && pItem->m_lootGenerated)
458 return EQUIP_ERR_LOOT_GONE;
459
460 // no maximum
461 if ((pProto->MaxCount <= 0 && pProto->ItemLimitCategory == 0) || pProto->MaxCount == 2147483647)
462 return EQUIP_ERR_OK;
463
464 if (pProto->MaxCount > 0)
465 {
466 uint32 curcount = GetItemCount(pProto->ItemId, true, pItem);
467 if (curcount + count > uint32(pProto->MaxCount))
468 {
469 if (no_space_count)
470 *no_space_count = count + curcount - pProto->MaxCount;
471 return EQUIP_ERR_ITEM_MAX_COUNT;
472 }
473 }
474
475 // check unique-equipped limit
476 if (pProto->ItemLimitCategory)
477 {
478 ItemLimitCategoryEntry const* limitEntry = sItemLimitCategoryStore.LookupEntry(pProto->ItemLimitCategory);
479 if (!limitEntry)
480 {
481 if (no_space_count)
482 *no_space_count = count;
483 return EQUIP_ERR_NOT_EQUIPPABLE;
484 }
485
486 if (limitEntry->mode == ITEM_LIMIT_CATEGORY_MODE_HAVE)
487 {
488 uint32 curcount = GetItemCountWithLimitCategory(pProto->ItemLimitCategory, pItem);
489 if (curcount + count > uint32(limitEntry->maxCount))
490 {
491 if (no_space_count)
492 *no_space_count = count + curcount - limitEntry->maxCount;
493 return EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_COUNT_EXCEEDED_IS;
494 }
495 }
496 }
497
498 return EQUIP_ERR_OK;
499}
500
501InventoryResult Player::CanStoreNewItem(uint8 bag, uint8 slot, ItemPosCountVec& dest, uint32 item, uint32 count, uint32* no_space_count /*= NULL*/) const
502{
503 return CanStoreItem(bag, slot, dest, item, count, NULL, false, no_space_count);
504}
505
506InventoryResult Player::CanStoreItem(uint8 bag, uint8 slot, ItemPosCountVec& dest, Item* pItem, bool swap /*= false*/) const
507{
508 if (!pItem)
509 return EQUIP_ERR_ITEM_NOT_FOUND;
510 uint32 count = pItem->GetCount();
511 return CanStoreItem(bag, slot, dest, pItem->GetEntry(), count, pItem, swap, NULL);
512}
513
514InventoryResult Player::CanStoreItem_InSpecificSlot(uint8 bag, uint8 slot, ItemPosCountVec& dest, ItemTemplate const* pProto, uint32& count, bool swap, Item* pSrcItem) const
515{
516 Item* pItem2 = GetItemByPos(bag, slot);
517
518 // ignore move item (this slot will be empty at move)
519 if (pItem2 == pSrcItem)
520 pItem2 = NULL;
521
522 uint32 need_space;
523
524 if (pSrcItem && pSrcItem->IsNotEmptyBag() && !IsBagPos(uint16(bag) << 8 | slot))
525 return EQUIP_ERR_DESTROY_NONEMPTY_BAG;
526
527 // empty specific slot - check item fit to slot
528 if (!pItem2 || swap)
529 {
530 if (bag == INVENTORY_SLOT_BAG_0)
531 {
532 // prevent cheating
533 if ((slot >= BUYBACK_SLOT_START && slot < BUYBACK_SLOT_END) || slot >= PLAYER_SLOT_END)
534 return EQUIP_ERR_WRONG_BAG_TYPE;
535 }
536 else
537 {
538 Bag* pBag = GetBagByPos(bag);
539 if (!pBag)
540 return EQUIP_ERR_WRONG_BAG_TYPE;
541
542 ItemTemplate const* pBagProto = pBag->GetTemplate();
543 if (!pBagProto)
544 return EQUIP_ERR_WRONG_BAG_TYPE;
545
546 if (slot >= pBagProto->ContainerSlots)
547 return EQUIP_ERR_WRONG_BAG_TYPE;
548
549 if (!ItemCanGoIntoBag(pProto, pBagProto))
550 return EQUIP_ERR_WRONG_BAG_TYPE;
551 }
552
553 // non empty stack with space
554 need_space = pProto->GetMaxStackSize();
555 }
556 // non empty slot, check item type
557 else
558 {
559 // can be merged at least partly
560 InventoryResult res = pItem2->CanBeMergedPartlyWith(pProto);
561 if (res != EQUIP_ERR_OK)
562 return res;
563
564 // free stack space or infinity
565 need_space = pProto->GetMaxStackSize() - pItem2->GetCount();
566 }
567
568 if (need_space > count)
569 need_space = count;
570
571 ItemPosCount newPosition = ItemPosCount((bag << 8) | slot, need_space);
572 if (!newPosition.isContainedIn(dest))
573 {
574 dest.push_back(newPosition);
575 count -= need_space;
576 }
577 return EQUIP_ERR_OK;
578}
579
580InventoryResult Player::CanStoreItem_InBag(uint8 bag, ItemPosCountVec& dest, ItemTemplate const* pProto, uint32& count, bool merge, bool non_specialized, Item* pSrcItem, uint8 skip_bag, uint8 skip_slot) const
581{
582 // skip specific bag already processed in first called CanStoreItem_InBag
583 if (bag == skip_bag)
584 return EQUIP_ERR_WRONG_BAG_TYPE;
585
586 // skip not existed bag or self targeted bag
587 Bag* pBag = GetBagByPos(bag);
588 if (!pBag || pBag == pSrcItem)
589 return EQUIP_ERR_WRONG_BAG_TYPE;
590
591 if (pSrcItem && pSrcItem->IsNotEmptyBag())
592 return EQUIP_ERR_DESTROY_NONEMPTY_BAG;
593
594 ItemTemplate const* pBagProto = pBag->GetTemplate();
595 if (!pBagProto)
596 return EQUIP_ERR_WRONG_BAG_TYPE;
597
598 // specialized bag mode or non-specilized
599 if (non_specialized != (pBagProto->Class == ITEM_CLASS_CONTAINER && pBagProto->SubClass == ITEM_SUBCLASS_CONTAINER))
600 return EQUIP_ERR_WRONG_BAG_TYPE;
601
602 if (!ItemCanGoIntoBag(pProto, pBagProto))
603 return EQUIP_ERR_WRONG_BAG_TYPE;
604
605 for (uint32 j = 0; j < pBag->GetBagSize(); j++)
606 {
607 // skip specific slot already processed in first called CanStoreItem_InSpecificSlot
608 if (j == skip_slot)
609 continue;
610
611 Item* pItem2 = GetItemByPos(bag, j);
612
613 // ignore move item (this slot will be empty at move)
614 if (pItem2 == pSrcItem)
615 pItem2 = NULL;
616
617 // if merge skip empty, if !merge skip non-empty
618 if ((pItem2 != NULL) != merge)
619 continue;
620
621 uint32 need_space = pProto->GetMaxStackSize();
622
623 if (pItem2)
624 {
625 // can be merged at least partly
626 uint8 res = pItem2->CanBeMergedPartlyWith(pProto);
627 if (res != EQUIP_ERR_OK)
628 continue;
629
630 // descrease at current stacksize
631 need_space -= pItem2->GetCount();
632 }
633
634 if (need_space > count)
635 need_space = count;
636
637 ItemPosCount newPosition = ItemPosCount((bag << 8) | j, need_space);
638 if (!newPosition.isContainedIn(dest))
639 {
640 dest.push_back(newPosition);
641 count -= need_space;
642
643 if (count == 0)
644 return EQUIP_ERR_OK;
645 }
646 }
647 return EQUIP_ERR_OK;
648}
649
650InventoryResult Player::CanStoreItem_InInventorySlots(uint8 slot_begin, uint8 slot_end, ItemPosCountVec& dest, ItemTemplate const* pProto, uint32& count, bool merge, Item* pSrcItem, uint8 skip_bag, uint8 skip_slot) const
651{
652 //this is never called for non-bag slots so we can do this
653 if (pSrcItem && pSrcItem->IsNotEmptyBag())
654 return EQUIP_ERR_DESTROY_NONEMPTY_BAG;
655
656 for (uint32 j = slot_begin; j < slot_end; j++)
657 {
658 // skip specific slot already processed in first called CanStoreItem_InSpecificSlot
659 if (INVENTORY_SLOT_BAG_0 == skip_bag && j == skip_slot)
660 continue;
661
662 Item* pItem2 = GetItemByPos(INVENTORY_SLOT_BAG_0, j);
663
664 // ignore move item (this slot will be empty at move)
665 if (pItem2 == pSrcItem)
666 pItem2 = NULL;
667
668 // if merge skip empty, if !merge skip non-empty
669 if ((pItem2 != NULL) != merge)
670 continue;
671
672 uint32 need_space = pProto->GetMaxStackSize();
673
674 if (pItem2)
675 {
676 // can be merged at least partly
677 uint8 res = pItem2->CanBeMergedPartlyWith(pProto);
678 if (res != EQUIP_ERR_OK)
679 continue;
680
681 // descrease at current stacksize
682 need_space -= pItem2->GetCount();
683 }
684
685 if (need_space > count)
686 need_space = count;
687
688 ItemPosCount newPosition = ItemPosCount((INVENTORY_SLOT_BAG_0 << 8) | j, need_space);
689 if (!newPosition.isContainedIn(dest))
690 {
691 dest.push_back(newPosition);
692 count -= need_space;
693
694 if (count == 0)
695 return EQUIP_ERR_OK;
696 }
697 }
698 return EQUIP_ERR_OK;
699}
700
701InventoryResult Player::CanStoreItem(uint8 bag, uint8 slot, ItemPosCountVec& dest, uint32 entry, uint32 count, Item* pItem, bool swap, uint32* no_space_count) const
702{
703 SF_LOG_DEBUG("entities.player.items", "STORAGE: CanStoreItem bag = %u, slot = %u, item = %u, count = %u", bag, slot, entry, count);
704
705 ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(entry);
706 if (!pProto)
707 {
708 if (no_space_count)
709 *no_space_count = count;
710 return swap ? EQUIP_ERR_CANT_SWAP : EQUIP_ERR_ITEM_NOT_FOUND;
711 }
712
713 if (pItem)
714 {
715 // item used
716 if (pItem->m_lootGenerated)
717 {
718 if (no_space_count)
719 *no_space_count = count;
720 return EQUIP_ERR_LOOT_GONE;
721 }
722
723 if (pItem->IsBindedNotWith(this))
724 {
725 if (no_space_count)
726 *no_space_count = count;
727 return EQUIP_ERR_NOT_OWNER;
728 }
729 }
730
731 // check count of items (skip for auto move for same player from bank)
732 uint32 no_similar_count = 0; // can't store this amount similar items
733 InventoryResult res = CanTakeMoreSimilarItems(entry, count, pItem, &no_similar_count);
734 if (res != EQUIP_ERR_OK)
735 {
736 if (count == no_similar_count)
737 {
738 if (no_space_count)
739 *no_space_count = no_similar_count;
740 return res;
741 }
742 count -= no_similar_count;
743 }
744
745 // in specific slot
746 if (bag != NULL_BAG && slot != NULL_SLOT)
747 {
748 res = CanStoreItem_InSpecificSlot(bag, slot, dest, pProto, count, swap, pItem);
749 if (res != EQUIP_ERR_OK)
750 {
751 if (no_space_count)
752 *no_space_count = count + no_similar_count;
753 return res;
754 }
755
756 if (count == 0)
757 {
758 if (no_similar_count == 0)
759 return EQUIP_ERR_OK;
760
761 if (no_space_count)
762 *no_space_count = count + no_similar_count;
763 return EQUIP_ERR_ITEM_MAX_COUNT;
764 }
765 }
766
767 // not specific slot or have space for partly store only in specific slot
768
769 // in specific bag
770 if (bag != NULL_BAG)
771 {
772 // search stack in bag for merge to
773 if (pProto->Stackable != 1)
774 {
775 if (bag == INVENTORY_SLOT_BAG_0) // inventory
776 {
777 res = CanStoreItem_InInventorySlots(INVENTORY_SLOT_ITEM_START, INVENTORY_SLOT_ITEM_END, dest, pProto, count, true, pItem, bag, slot);
778 if (res != EQUIP_ERR_OK)
779 {
780 if (no_space_count)
781 *no_space_count = count + no_similar_count;
782 return res;
783 }
784
785 if (count == 0)
786 {
787 if (no_similar_count == 0)
788 return EQUIP_ERR_OK;
789
790 if (no_space_count)
791 *no_space_count = count + no_similar_count;
792 return EQUIP_ERR_ITEM_MAX_COUNT;
793 }
794 }
795 else // equipped bag
796 {
797 // we need check 2 time (specialized/non_specialized), use NULL_BAG to prevent skipping bag
798 res = CanStoreItem_InBag(bag, dest, pProto, count, true, false, pItem, NULL_BAG, slot);
799 if (res != EQUIP_ERR_OK)
800 res = CanStoreItem_InBag(bag, dest, pProto, count, true, true, pItem, NULL_BAG, slot);
801
802 if (res != EQUIP_ERR_OK)
803 {
804 if (no_space_count)
805 *no_space_count = count + no_similar_count;
806 return res;
807 }
808
809 if (count == 0)
810 {
811 if (no_similar_count == 0)
812 return EQUIP_ERR_OK;
813
814 if (no_space_count)
815 *no_space_count = count + no_similar_count;
816 return EQUIP_ERR_ITEM_MAX_COUNT;
817 }
818 }
819 }
820
821 // search free slot in bag for place to
822 if (bag == INVENTORY_SLOT_BAG_0) // inventory
823 {
824 res = CanStoreItem_InInventorySlots(INVENTORY_SLOT_ITEM_START, INVENTORY_SLOT_ITEM_END, dest, pProto, count, false, pItem, bag, slot);
825 if (res != EQUIP_ERR_OK)
826 {
827 if (no_space_count)
828 *no_space_count = count + no_similar_count;
829 return res;
830 }
831
832 if (count == 0)
833 {
834 if (no_similar_count == 0)
835 return EQUIP_ERR_OK;
836
837 if (no_space_count)
838 *no_space_count = count + no_similar_count;
839 return EQUIP_ERR_ITEM_MAX_COUNT;
840 }
841 }
842 else // equipped bag
843 {
844 res = CanStoreItem_InBag(bag, dest, pProto, count, false, false, pItem, NULL_BAG, slot);
845 if (res != EQUIP_ERR_OK)
846 res = CanStoreItem_InBag(bag, dest, pProto, count, false, true, pItem, NULL_BAG, slot);
847
848 if (res != EQUIP_ERR_OK)
849 {
850 if (no_space_count)
851 *no_space_count = count + no_similar_count;
852 return res;
853 }
854
855 if (count == 0)
856 {
857 if (no_similar_count == 0)
858 return EQUIP_ERR_OK;
859
860 if (no_space_count)
861 *no_space_count = count + no_similar_count;
862 return EQUIP_ERR_ITEM_MAX_COUNT;
863 }
864 }
865 }
866
867 // not specific bag or have space for partly store only in specific bag
868
869 // search stack for merge to
870 if (pProto->Stackable != 1)
871 {
872 res = CanStoreItem_InInventorySlots(INVENTORY_SLOT_ITEM_START, INVENTORY_SLOT_ITEM_END, dest, pProto, count, true, pItem, bag, slot);
873 if (res != EQUIP_ERR_OK)
874 {
875 if (no_space_count)
876 *no_space_count = count + no_similar_count;
877 return res;
878 }
879
880 if (count == 0)
881 {
882 if (no_similar_count == 0)
883 return EQUIP_ERR_OK;
884
885 if (no_space_count)
886 *no_space_count = count + no_similar_count;
887 return EQUIP_ERR_ITEM_MAX_COUNT;
888 }
889
890 if (pProto->BagFamily)
891 {
892 for (uint32 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
893 {
894 res = CanStoreItem_InBag(i, dest, pProto, count, true, false, pItem, bag, slot);
895 if (res != EQUIP_ERR_OK)
896 continue;
897
898 if (count == 0)
899 {
900 if (no_similar_count == 0)
901 return EQUIP_ERR_OK;
902
903 if (no_space_count)
904 *no_space_count = count + no_similar_count;
905 return EQUIP_ERR_ITEM_MAX_COUNT;
906 }
907 }
908 }
909
910 for (uint32 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
911 {
912 res = CanStoreItem_InBag(i, dest, pProto, count, true, true, pItem, bag, slot);
913 if (res != EQUIP_ERR_OK)
914 continue;
915
916 if (count == 0)
917 {
918 if (no_similar_count == 0)
919 return EQUIP_ERR_OK;
920
921 if (no_space_count)
922 *no_space_count = count + no_similar_count;
923 return EQUIP_ERR_ITEM_MAX_COUNT;
924 }
925 }
926 }
927
928 // search free slot - special bag case
929 if (pProto->BagFamily)
930 {
931 for (uint32 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
932 {
933 res = CanStoreItem_InBag(i, dest, pProto, count, false, false, pItem, bag, slot);
934 if (res != EQUIP_ERR_OK)
935 continue;
936
937 if (count == 0)
938 {
939 if (no_similar_count == 0)
940 return EQUIP_ERR_OK;
941
942 if (no_space_count)
943 *no_space_count = count + no_similar_count;
944 return EQUIP_ERR_ITEM_MAX_COUNT;
945 }
946 }
947 }
948
949 if (pItem && pItem->IsNotEmptyBag())
950 return EQUIP_ERR_BAG_IN_BAG;
951
952 // search free slot
953 res = CanStoreItem_InInventorySlots(INVENTORY_SLOT_ITEM_START, INVENTORY_SLOT_ITEM_END, dest, pProto, count, false, pItem, bag, slot);
954 if (res != EQUIP_ERR_OK)
955 {
956 if (no_space_count)
957 *no_space_count = count + no_similar_count;
958 return res;
959 }
960
961 if (count == 0)
962 {
963 if (no_similar_count == 0)
964 return EQUIP_ERR_OK;
965
966 if (no_space_count)
967 *no_space_count = count + no_similar_count;
968 return EQUIP_ERR_ITEM_MAX_COUNT;
969 }
970
971 for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
972 {
973 res = CanStoreItem_InBag(i, dest, pProto, count, false, true, pItem, bag, slot);
974 if (res != EQUIP_ERR_OK)
975 continue;
976
977 if (count == 0)
978 {
979 if (no_similar_count == 0)
980 return EQUIP_ERR_OK;
981
982 if (no_space_count)
983 *no_space_count = count + no_similar_count;
984 return EQUIP_ERR_ITEM_MAX_COUNT;
985 }
986 }
987
988 if (no_space_count)
989 *no_space_count = count + no_similar_count;
990
991 return EQUIP_ERR_INV_FULL;
992}
993
995InventoryResult Player::CanStoreItems(Item** pItems, int count) const
996{
997 Item* pItem2;
998
999 // fill space table
1000 int inv_slot_items[INVENTORY_SLOT_ITEM_END - INVENTORY_SLOT_ITEM_START];
1001 int inv_bags[INVENTORY_SLOT_BAG_END - INVENTORY_SLOT_BAG_START][MAX_BAG_SIZE];
1002
1003 memset(inv_slot_items, 0, sizeof(int) * (INVENTORY_SLOT_ITEM_END - INVENTORY_SLOT_ITEM_START));
1004 memset(inv_bags, 0, sizeof(int) * (INVENTORY_SLOT_BAG_END - INVENTORY_SLOT_BAG_START) * MAX_BAG_SIZE);
1005
1006 for (uint8 i = INVENTORY_SLOT_ITEM_START; i < INVENTORY_SLOT_ITEM_END; i++)
1007 {
1008 pItem2 = GetItemByPos(INVENTORY_SLOT_BAG_0, i);
1009 if (pItem2 && !pItem2->IsInTrade())
1010 inv_slot_items[i - INVENTORY_SLOT_ITEM_START] = pItem2->GetCount();
1011 }
1012
1013 for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
1014 if (Bag* pBag = GetBagByPos(i))
1015 for (uint32 j = 0; j < pBag->GetBagSize(); j++)
1016 {
1017 pItem2 = GetItemByPos(i, j);
1018 if (pItem2 && !pItem2->IsInTrade())
1019 inv_bags[i - INVENTORY_SLOT_BAG_START][j] = pItem2->GetCount();
1020 }
1021
1022 // check free space for all items
1023 for (int k = 0; k < count; ++k)
1024 {
1025 Item* pItem = pItems[k];
1026
1027 // no item
1028 if (!pItem)
1029 continue;
1030
1031 SF_LOG_DEBUG("entities.player.items", "STORAGE: CanStoreItems %i. item = %u, count = %u", k + 1, pItem->GetEntry(), pItem->GetCount());
1032 ItemTemplate const* pProto = pItem->GetTemplate();
1033
1034 // strange item
1035 if (!pProto)
1036 return EQUIP_ERR_ITEM_NOT_FOUND;
1037
1038 // item used
1039 if (pItem->m_lootGenerated)
1040 return EQUIP_ERR_LOOT_GONE;
1041
1042 // item it 'bind'
1043 if (pItem->IsBindedNotWith(this))
1044 return EQUIP_ERR_NOT_OWNER;
1045
1046 ItemTemplate const* pBagProto;
1047
1048 // item is 'one item only'
1049 InventoryResult res = CanTakeMoreSimilarItems(pItem);
1050 if (res != EQUIP_ERR_OK)
1051 return res;
1052
1053 // search stack for merge to
1054 if (pProto->Stackable != 1)
1055 {
1056 bool b_found = false;
1057
1058 for (int t = INVENTORY_SLOT_ITEM_START; t < INVENTORY_SLOT_ITEM_END; ++t)
1059 {
1060 pItem2 = GetItemByPos(INVENTORY_SLOT_BAG_0, t);
1061 if (pItem2 && pItem2->CanBeMergedPartlyWith(pProto) == EQUIP_ERR_OK && inv_slot_items[t - INVENTORY_SLOT_ITEM_START] + pItem->GetCount() <= pProto->GetMaxStackSize())
1062 {
1063 inv_slot_items[t - INVENTORY_SLOT_ITEM_START] += pItem->GetCount();
1064 b_found = true;
1065 break;
1066 }
1067 }
1068 if (b_found)
1069 continue;
1070
1071 for (int t = INVENTORY_SLOT_BAG_START; !b_found && t < INVENTORY_SLOT_BAG_END; ++t)
1072 {
1073 if (Bag* bag = GetBagByPos(t))
1074 {
1075 if (ItemCanGoIntoBag(pItem->GetTemplate(), bag->GetTemplate()))
1076 {
1077 for (uint32 j = 0; j < bag->GetBagSize(); j++)
1078 {
1079 pItem2 = GetItemByPos(t, j);
1080 if (pItem2 && pItem2->CanBeMergedPartlyWith(pProto) == EQUIP_ERR_OK && inv_bags[t - INVENTORY_SLOT_BAG_START][j] + pItem->GetCount() <= pProto->GetMaxStackSize())
1081 {
1082 inv_bags[t - INVENTORY_SLOT_BAG_START][j] += pItem->GetCount();
1083 b_found = true;
1084 break;
1085 }
1086 }
1087 }
1088 }
1089 }
1090 if (b_found)
1091 continue;
1092 }
1093
1094 // special bag case
1095 if (pProto->BagFamily)
1096 {
1097 bool b_found = false;
1098
1099 for (int t = INVENTORY_SLOT_BAG_START; !b_found && t < INVENTORY_SLOT_BAG_END; ++t)
1100 {
1101 if (Bag* bag = GetBagByPos(t))
1102 {
1103 pBagProto = bag->GetTemplate();
1104
1105 // not plain container check
1106 if (pBagProto && (pBagProto->Class != ITEM_CLASS_CONTAINER || pBagProto->SubClass != ITEM_SUBCLASS_CONTAINER) &&
1107 ItemCanGoIntoBag(pProto, pBagProto))
1108 {
1109 for (uint32 j = 0; j < bag->GetBagSize(); j++)
1110 {
1111 if (inv_bags[t - INVENTORY_SLOT_BAG_START][j] == 0)
1112 {
1113 inv_bags[t - INVENTORY_SLOT_BAG_START][j] = 1;
1114 b_found = true;
1115 break;
1116 }
1117 }
1118 }
1119 }
1120 }
1121 if (b_found)
1122 continue;
1123 }
1124
1125 // search free slot
1126 bool b_found = false;
1127 for (int t = INVENTORY_SLOT_ITEM_START; t < INVENTORY_SLOT_ITEM_END; ++t)
1128 {
1129 if (inv_slot_items[t - INVENTORY_SLOT_ITEM_START] == 0)
1130 {
1131 inv_slot_items[t - INVENTORY_SLOT_ITEM_START] = 1;
1132 b_found = true;
1133 break;
1134 }
1135 }
1136 if (b_found)
1137 continue;
1138
1139 // search free slot in bags
1140 for (int t = INVENTORY_SLOT_BAG_START; !b_found && t < INVENTORY_SLOT_BAG_END; ++t)
1141 {
1142 if (Bag* bag = GetBagByPos(t))
1143 {
1144 pBagProto = bag->GetTemplate();
1145
1146 // special bag already checked
1147 if (pBagProto && (pBagProto->Class != ITEM_CLASS_CONTAINER || pBagProto->SubClass != ITEM_SUBCLASS_CONTAINER))
1148 continue;
1149
1150 for (uint32 j = 0; j < bag->GetBagSize(); j++)
1151 {
1152 if (inv_bags[t - INVENTORY_SLOT_BAG_START][j] == 0)
1153 {
1154 inv_bags[t - INVENTORY_SLOT_BAG_START][j] = 1;
1155 b_found = true;
1156 break;
1157 }
1158 }
1159 }
1160 }
1161
1162 // no free slot found?
1163 if (!b_found)
1164 return EQUIP_ERR_INV_FULL;
1165 }
1166
1167 return EQUIP_ERR_OK;
1168}
1169
1170bool Player::StoreNewItemInBestSlots(uint32 titem_id, uint32 titem_amount)
1171{
1172 SF_LOG_DEBUG("entities.player.items", "STORAGE: Creating initial item, itemId = %u, count = %u", titem_id, titem_amount);
1173
1174 // attempt equip by one
1175 while (titem_amount > 0)
1176 {
1177 uint16 eDest;
1178 InventoryResult msg = CanEquipNewItem(NULL_SLOT, eDest, titem_id, false);
1179 if (msg != EQUIP_ERR_OK)
1180 break;
1181
1182 EquipNewItem(eDest, titem_id, true);
1183 AutoUnequipOffhandIfNeed();
1184 --titem_amount;
1185 }
1186
1187 if (titem_amount == 0)
1188 return true; // equipped
1189
1190 // attempt store
1191 ItemPosCountVec sDest;
1192 // store in main bag to simplify second pass (special bags can be not equipped yet at this moment)
1193 InventoryResult msg = CanStoreNewItem(INVENTORY_SLOT_BAG_0, NULL_SLOT, sDest, titem_id, titem_amount);
1194 if (msg == EQUIP_ERR_OK)
1195 {
1196 StoreNewItem(sDest, titem_id, true, Item::GenerateItemRandomPropertyId(titem_id));
1197 return true; // stored
1198 }
1199
1200 // item can't be added
1201 SF_LOG_ERROR("entities.player.items", "STORAGE: Can't equip or store initial item %u for race %u class %u, error msg = %u", titem_id, getRace(), getClass(), msg);
1202 return false;
1203}
1204
1205InventoryResult Player::CanUnequipItems(uint32 item, uint32 count) const
1206{
1207 uint32 tempcount = 0;
1208
1209 InventoryResult res = EQUIP_ERR_OK;
1210
1211 for (uint8 i = EQUIPMENT_SLOT_START; i < INVENTORY_SLOT_BAG_END; ++i)
1212 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
1213 if (pItem->GetEntry() == item)
1214 {
1215 InventoryResult ires = CanUnequipItem(INVENTORY_SLOT_BAG_0 << 8 | i, false);
1216 if (ires == EQUIP_ERR_OK)
1217 {
1218 tempcount += pItem->GetCount();
1219 if (tempcount >= count)
1220 return EQUIP_ERR_OK;
1221 }
1222 else
1223 res = ires;
1224 }
1225
1226 for (uint8 i = INVENTORY_SLOT_ITEM_START; i < INVENTORY_SLOT_ITEM_END; ++i)
1227 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
1228 if (pItem->GetEntry() == item)
1229 {
1230 tempcount += pItem->GetCount();
1231 if (tempcount >= count)
1232 return EQUIP_ERR_OK;
1233 }
1234
1235
1236 for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; ++i)
1237 if (Bag* pBag = GetBagByPos(i))
1238 for (uint32 j = 0; j < pBag->GetBagSize(); ++j)
1239 if (Item* pItem = GetItemByPos(i, j))
1240 if (pItem->GetEntry() == item)
1241 {
1242 tempcount += pItem->GetCount();
1243 if (tempcount >= count)
1244 return EQUIP_ERR_OK;
1245 }
1246
1247 // not found req. item count and have unequippable items
1248 return res;
1249}
1250
1251InventoryResult Player::CanEquipNewItem(uint8 slot, uint16& dest, uint32 item, bool swap) const
1252{
1253 dest = 0;
1254 Item* pItem = Item::CreateItem(item, 1, this);
1255 if (pItem)
1256 {
1257 InventoryResult result = CanEquipItem(slot, dest, pItem, swap);
1258 delete pItem;
1259 return result;
1260 }
1261
1262 return EQUIP_ERR_ITEM_NOT_FOUND;
1263}
1264
1265InventoryResult Player::CanEquipItem(uint8 slot, uint16& dest, Item* pItem, bool swap, bool not_loading) const
1266{
1267 dest = 0;
1268 if (pItem)
1269 {
1270 SF_LOG_DEBUG("entities.player.items", "STORAGE: CanEquipItem slot = %u, item = %u, count = %u", slot, pItem->GetEntry(), pItem->GetCount());
1271 ItemTemplate const* pProto = pItem->GetTemplate();
1272 if (pProto)
1273 {
1274 // item used
1275 if (pItem->m_lootGenerated)
1276 return EQUIP_ERR_LOOT_GONE;
1277
1278 if (pItem->IsBindedNotWith(this))
1279 return EQUIP_ERR_NOT_OWNER;
1280
1281 // check count of items (skip for auto move for same player from bank)
1282 InventoryResult res = CanTakeMoreSimilarItems(pItem);
1283 if (res != EQUIP_ERR_OK)
1284 return res;
1285
1286 // check this only in game
1287 if (not_loading)
1288 {
1289 // May be here should be more stronger checks; STUNNED checked
1290 // ROOT, CONFUSED, DISTRACTED, FLEEING this needs to be checked.
1291 if (HasUnitState(UNIT_STATE_STUNNED))
1292 return EQUIP_ERR_GENERIC_STUNNED;
1293
1294 // do not allow equipping gear except weapons, offhands, projectiles, relics in
1295 // - combat
1296 // - in-progress arenas
1297 if (!pProto->CanChangeEquipStateInCombat())
1298 {
1299 if (IsInCombat())
1300 return EQUIP_ERR_NOT_IN_COMBAT;
1301
1302 if (Battleground* bg = GetBattleground())
1303 if (bg->isArena() && bg->GetStatus() == STATUS_IN_PROGRESS)
1304 return EQUIP_ERR_NOT_DURING_ARENA_MATCH;
1305 }
1306
1307 if (IsInCombat() && (pProto->Class == ITEM_CLASS_WEAPON || pProto->InventoryType == INVTYPE_RELIC) && m_weaponChangeTimer != 0)
1308 return EQUIP_ERR_CLIENT_LOCKED_OUT; // maybe exist better err
1309
1310 if (IsNonMeleeSpellCasted(false))
1311 return EQUIP_ERR_CLIENT_LOCKED_OUT;
1312 }
1313
1314 ScalingStatDistributionEntry const* ssd = pProto->ScalingStatDistribution ? sScalingStatDistributionStore.LookupEntry(pProto->ScalingStatDistribution) : 0;
1315 // check allowed level (extend range to upper values if MaxLevel more or equal max player level, this let GM set high level with 1...max range items)
1316 if (ssd && ssd->MaxLevel < DEFAULT_MAX_LEVEL && ssd->MaxLevel < getLevel())
1317 return EQUIP_ERR_NOT_EQUIPPABLE;
1318
1319 uint8 eslot = FindEquipSlot(pProto, slot, swap);
1320 if (eslot == NULL_SLOT)
1321 return EQUIP_ERR_NOT_EQUIPPABLE;
1322
1323 res = CanUseItem(pItem, not_loading);
1324 if (res != EQUIP_ERR_OK)
1325 return res;
1326
1327 if (!swap && GetItemByPos(INVENTORY_SLOT_BAG_0, eslot))
1328 return EQUIP_ERR_NO_SLOT_AVAILABLE;
1329
1330 // if we are swapping 2 equiped items, CanEquipUniqueItem check
1331 // should ignore the item we are trying to swap, and not the
1332 // destination item. CanEquipUniqueItem should ignore destination
1333 // item only when we are swapping weapon from bag
1334 uint8 ignore = uint8(NULL_SLOT);
1335 switch (eslot)
1336 {
1337 case EQUIPMENT_SLOT_MAINHAND:
1338 ignore = EQUIPMENT_SLOT_OFFHAND;
1339 break;
1340 case EQUIPMENT_SLOT_OFFHAND:
1341 ignore = EQUIPMENT_SLOT_MAINHAND;
1342 break;
1343 case EQUIPMENT_SLOT_FINGER1:
1344 ignore = EQUIPMENT_SLOT_FINGER2;
1345 break;
1346 case EQUIPMENT_SLOT_FINGER2:
1347 ignore = EQUIPMENT_SLOT_FINGER1;
1348 break;
1349 case EQUIPMENT_SLOT_TRINKET1:
1350 ignore = EQUIPMENT_SLOT_TRINKET2;
1351 break;
1352 case EQUIPMENT_SLOT_TRINKET2:
1353 ignore = EQUIPMENT_SLOT_TRINKET1;
1354 break;
1355 }
1356
1357 if (ignore == uint8(NULL_SLOT) || pItem != GetItemByPos(INVENTORY_SLOT_BAG_0, ignore))
1358 ignore = eslot;
1359
1360 InventoryResult res2 = CanEquipUniqueItem(pItem, swap ? ignore : uint8(NULL_SLOT));
1361 if (res2 != EQUIP_ERR_OK)
1362 return res2;
1363
1364 // check unique-equipped special item classes
1365 if (pProto->Class == ITEM_CLASS_QUIVER)
1366 for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; ++i)
1367 if (Item* pBag = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
1368 if (pBag != pItem)
1369 if (ItemTemplate const* pBagProto = pBag->GetTemplate())
1370 if (pBagProto->Class == pProto->Class && (!swap || pBag->GetSlot() != eslot))
1371 return (pBagProto->SubClass == ITEM_SUBCLASS_AMMO_POUCH)
1372 ? EQUIP_ERR_ONLY_ONE_AMMO
1373 : EQUIP_ERR_ONLY_ONE_QUIVER;
1374
1375 uint32 type = pProto->InventoryType;
1376
1377 if (eslot == EQUIPMENT_SLOT_OFFHAND)
1378 {
1379 // Do not allow polearm to be equipped in the offhand (rare case for the only 1h polearm 41750)
1380 if (type == INVTYPE_WEAPON && pProto->SubClass == ITEM_SUBCLASS_WEAPON_POLEARM)
1381 return EQUIP_ERR_2HSKILLNOTFOUND;
1382 else if (type == INVTYPE_WEAPON || type == INVTYPE_WEAPONOFFHAND)
1383 {
1384 if (!CanDualWield())
1385 return EQUIP_ERR_2HSKILLNOTFOUND;
1386 }
1387 else if (type == INVTYPE_2HWEAPON)
1388 {
1389 if (!CanDualWield() || !CanTitanGrip())
1390 return EQUIP_ERR_2HSKILLNOTFOUND;
1391 }
1392
1393 if (IsTwoHandUsed())
1394 return EQUIP_ERR_2HANDED_EQUIPPED;
1395 }
1396
1397 // equip two-hand weapon case (with possible unequip 2 items)
1398 if (type == INVTYPE_2HWEAPON)
1399 {
1400 if (eslot == EQUIPMENT_SLOT_OFFHAND)
1401 {
1402 if (!CanTitanGrip())
1403 return EQUIP_ERR_NOT_EQUIPPABLE;
1404 }
1405 else if (eslot != EQUIPMENT_SLOT_MAINHAND)
1406 return EQUIP_ERR_NOT_EQUIPPABLE;
1407
1408 if (!CanTitanGrip())
1409 {
1410 // offhand item must can be stored in inventory for offhand item and it also must be unequipped
1411 Item* offItem = GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
1412 ItemPosCountVec off_dest;
1413 if (offItem && (!not_loading ||
1414 CanUnequipItem(uint16(INVENTORY_SLOT_BAG_0) << 8 | EQUIPMENT_SLOT_OFFHAND, false) != EQUIP_ERR_OK ||
1415 CanStoreItem(NULL_BAG, NULL_SLOT, off_dest, offItem, false) != EQUIP_ERR_OK))
1416 return swap ? EQUIP_ERR_CANT_SWAP : EQUIP_ERR_INV_FULL;
1417 }
1418 }
1419 dest = ((INVENTORY_SLOT_BAG_0 << 8) | eslot);
1420 return EQUIP_ERR_OK;
1421 }
1422 }
1423
1424 return !swap ? EQUIP_ERR_ITEM_NOT_FOUND : EQUIP_ERR_CANT_SWAP;
1425}
1426
1427InventoryResult Player::CanUnequipItem(uint16 pos, bool swap) const
1428{
1429 // Applied only to equipped items and bank bags
1430 if (!IsEquipmentPos(pos) && !IsBagPos(pos))
1431 return EQUIP_ERR_OK;
1432
1433 Item* pItem = GetItemByPos(pos);
1434
1435 // Applied only to existed equipped item
1436 if (!pItem)
1437 return EQUIP_ERR_OK;
1438
1439 SF_LOG_DEBUG("entities.player.items", "STORAGE: CanUnequipItem slot = %u, item = %u, count = %u", pos, pItem->GetEntry(), pItem->GetCount());
1440
1441 ItemTemplate const* pProto = pItem->GetTemplate();
1442 if (!pProto)
1443 return EQUIP_ERR_ITEM_NOT_FOUND;
1444
1445 // item used
1446 if (pItem->m_lootGenerated)
1447 return EQUIP_ERR_LOOT_GONE;
1448
1449 // do not allow unequipping gear except weapons, offhands, projectiles, relics in
1450 // - combat
1451 // - in-progress arenas
1452 if (!pProto->CanChangeEquipStateInCombat())
1453 {
1454 if (IsInCombat())
1455 return EQUIP_ERR_NOT_IN_COMBAT;
1456
1457 if (Battleground* bg = GetBattleground())
1458 if (bg->isArena() && bg->GetStatus() == STATUS_IN_PROGRESS)
1459 return EQUIP_ERR_NOT_DURING_ARENA_MATCH;
1460 }
1461
1462 if (!swap && pItem->IsNotEmptyBag())
1463 return EQUIP_ERR_DESTROY_NONEMPTY_BAG;
1464
1465 return EQUIP_ERR_OK;
1466}
1467
1468InventoryResult Player::CanBankItem(uint8 bag, uint8 slot, ItemPosCountVec& dest, Item* pItem, bool swap, bool not_loading) const
1469{
1470 if (!pItem)
1471 return swap ? EQUIP_ERR_CANT_SWAP : EQUIP_ERR_ITEM_NOT_FOUND;
1472
1473 uint32 count = pItem->GetCount();
1474
1475 SF_LOG_DEBUG("entities.player.items", "STORAGE: CanBankItem bag = %u, slot = %u, item = %u, count = %u", bag, slot, pItem->GetEntry(), pItem->GetCount());
1476 ItemTemplate const* pProto = pItem->GetTemplate();
1477 if (!pProto)
1478 return swap ? EQUIP_ERR_CANT_SWAP : EQUIP_ERR_ITEM_NOT_FOUND;
1479
1480 // item used
1481 if (pItem->m_lootGenerated)
1482 return EQUIP_ERR_LOOT_GONE;
1483
1484 if (pItem->IsBindedNotWith(this))
1485 return EQUIP_ERR_NOT_OWNER;
1486
1487 // Currency Tokenizer are not supposed to be swapped out of their hidden bag
1488 if (pItem->IsCurrencyToken())
1489 {
1490 SF_LOG_ERROR("entities.player", "Possible hacking attempt: Player %s [guid: %u] tried to move token [guid: %u, entry: %u] out of the currency bag!",
1491 GetName().c_str(), GetGUIDLow(), pItem->GetGUIDLow(), pProto->ItemId);
1492 return EQUIP_ERR_CANT_SWAP;
1493 }
1494
1495 // check count of items (skip for auto move for same player from bank)
1496 InventoryResult res = CanTakeMoreSimilarItems(pItem);
1497 if (res != EQUIP_ERR_OK)
1498 return res;
1499
1500 // in specific slot
1501 if (bag != NULL_BAG && slot != NULL_SLOT)
1502 {
1503 if (slot >= BANK_SLOT_BAG_START && slot < BANK_SLOT_BAG_END)
1504 {
1505 if (!pItem->IsBag())
1506 return EQUIP_ERR_WRONG_SLOT;
1507
1508 if (slot - BANK_SLOT_BAG_START >= GetBankBagSlotCount())
1509 return EQUIP_ERR_NO_BANK_SLOT;
1510
1511 res = CanUseItem(pItem, not_loading);
1512 if (res != EQUIP_ERR_OK)
1513 return res;
1514 }
1515
1516 res = CanStoreItem_InSpecificSlot(bag, slot, dest, pProto, count, swap, pItem);
1517 if (res != EQUIP_ERR_OK)
1518 return res;
1519
1520 if (count == 0)
1521 return EQUIP_ERR_OK;
1522 }
1523
1524 // not specific slot or have space for partly store only in specific slot
1525
1526 // in specific bag
1527 if (bag != NULL_BAG)
1528 {
1529 if (pItem->IsNotEmptyBag())
1530 return EQUIP_ERR_BAG_IN_BAG;
1531
1532 // search stack in bag for merge to
1533 if (pProto->Stackable != 1)
1534 {
1535 if (bag == INVENTORY_SLOT_BAG_0)
1536 {
1537 res = CanStoreItem_InInventorySlots(BANK_SLOT_ITEM_START, BANK_SLOT_ITEM_END, dest, pProto, count, true, pItem, bag, slot);
1538 if (res != EQUIP_ERR_OK)
1539 return res;
1540
1541 if (count == 0)
1542 return EQUIP_ERR_OK;
1543 }
1544 else
1545 {
1546 res = CanStoreItem_InBag(bag, dest, pProto, count, true, false, pItem, NULL_BAG, slot);
1547 if (res != EQUIP_ERR_OK)
1548 res = CanStoreItem_InBag(bag, dest, pProto, count, true, true, pItem, NULL_BAG, slot);
1549
1550 if (res != EQUIP_ERR_OK)
1551 return res;
1552
1553 if (count == 0)
1554 return EQUIP_ERR_OK;
1555 }
1556 }
1557
1558 // search free slot in bag
1559 if (bag == INVENTORY_SLOT_BAG_0)
1560 {
1561 res = CanStoreItem_InInventorySlots(BANK_SLOT_ITEM_START, BANK_SLOT_ITEM_END, dest, pProto, count, false, pItem, bag, slot);
1562 if (res != EQUIP_ERR_OK)
1563 return res;
1564
1565 if (count == 0)
1566 return EQUIP_ERR_OK;
1567 }
1568 else
1569 {
1570 res = CanStoreItem_InBag(bag, dest, pProto, count, false, false, pItem, NULL_BAG, slot);
1571 if (res != EQUIP_ERR_OK)
1572 res = CanStoreItem_InBag(bag, dest, pProto, count, false, true, pItem, NULL_BAG, slot);
1573
1574 if (res != EQUIP_ERR_OK)
1575 return res;
1576
1577 if (count == 0)
1578 return EQUIP_ERR_OK;
1579 }
1580 }
1581
1582 // not specific bag or have space for partly store only in specific bag
1583
1584 // search stack for merge to
1585 if (pProto->Stackable != 1)
1586 {
1587 // in slots
1588 res = CanStoreItem_InInventorySlots(BANK_SLOT_ITEM_START, BANK_SLOT_ITEM_END, dest, pProto, count, true, pItem, bag, slot);
1589 if (res != EQUIP_ERR_OK)
1590 return res;
1591
1592 if (count == 0)
1593 return EQUIP_ERR_OK;
1594
1595 // in special bags
1596 if (pProto->BagFamily)
1597 {
1598 for (uint8 i = BANK_SLOT_BAG_START; i < BANK_SLOT_BAG_END; i++)
1599 {
1600 res = CanStoreItem_InBag(i, dest, pProto, count, true, false, pItem, bag, slot);
1601 if (res != EQUIP_ERR_OK)
1602 continue;
1603
1604 if (count == 0)
1605 return EQUIP_ERR_OK;
1606 }
1607 }
1608
1609 for (uint8 i = BANK_SLOT_BAG_START; i < BANK_SLOT_BAG_END; i++)
1610 {
1611 res = CanStoreItem_InBag(i, dest, pProto, count, true, true, pItem, bag, slot);
1612 if (res != EQUIP_ERR_OK)
1613 continue;
1614
1615 if (count == 0)
1616 return EQUIP_ERR_OK;
1617 }
1618 }
1619
1620 // search free place in special bag
1621 if (pProto->BagFamily)
1622 {
1623 for (uint8 i = BANK_SLOT_BAG_START; i < BANK_SLOT_BAG_END; i++)
1624 {
1625 res = CanStoreItem_InBag(i, dest, pProto, count, false, false, pItem, bag, slot);
1626 if (res != EQUIP_ERR_OK)
1627 continue;
1628
1629 if (count == 0)
1630 return EQUIP_ERR_OK;
1631 }
1632 }
1633
1634 // search free space
1635 res = CanStoreItem_InInventorySlots(BANK_SLOT_ITEM_START, BANK_SLOT_ITEM_END, dest, pProto, count, false, pItem, bag, slot);
1636 if (res != EQUIP_ERR_OK)
1637 return res;
1638
1639 if (count == 0)
1640 return EQUIP_ERR_OK;
1641
1642 for (uint8 i = BANK_SLOT_BAG_START; i < BANK_SLOT_BAG_END; i++)
1643 {
1644 res = CanStoreItem_InBag(i, dest, pProto, count, false, true, pItem, bag, slot);
1645 if (res != EQUIP_ERR_OK)
1646 continue;
1647
1648 if (count == 0)
1649 return EQUIP_ERR_OK;
1650 }
1651 return EQUIP_ERR_BANK_FULL;
1652}
1653
1654InventoryResult Player::CanUseItem(Item* pItem, bool not_loading) const
1655{
1656 if (pItem)
1657 {
1658 SF_LOG_DEBUG("entities.player.items", "STORAGE: CanUseItem item = %u", pItem->GetEntry());
1659
1660 if (!IsAlive() && not_loading)
1661 return EQUIP_ERR_PLAYER_DEAD;
1662
1663 //if (isStunned())
1664 // return EQUIP_ERR_GENERIC_STUNNED;
1665
1666 ItemTemplate const* pProto = pItem->GetTemplate();
1667 if (pProto)
1668 {
1669 if (pItem->IsBindedNotWith(this))
1670 return EQUIP_ERR_NOT_OWNER;
1671
1672 InventoryResult res = CanUseItem(pProto);
1673 if (res != EQUIP_ERR_OK)
1674 return res;
1675
1676 if (pItem->GetSkill() != 0)
1677 {
1678 bool allowEquip = false;
1679 uint32 itemSkill = pItem->GetSkill();
1680 // Armor that is binded to account can "morph" from plate to mail, etc. if skill is not learned yet.
1681 if (pProto->Quality == ITEM_QUALITY_HEIRLOOM && pProto->Class == ITEM_CLASS_ARMOR && !HasSkill(itemSkill))
1682 {
1684 // In fact it's a visual bug, everything works properly... I need sniffs of operations with
1685 // binded to account items from off server.
1686
1687 switch (getClass())
1688 {
1689 case CLASS_HUNTER:
1690 case CLASS_SHAMAN:
1691 allowEquip = (itemSkill == SKILL_MAIL);
1692 break;
1693 case CLASS_PALADIN:
1694 case CLASS_WARRIOR:
1695 allowEquip = (itemSkill == SKILL_PLATE_MAIL);
1696 break;
1697 }
1698 }
1699 if (!allowEquip && GetSkillValue(itemSkill) == 0)
1700 return EQUIP_ERR_PROFICIENCY_NEEDED;
1701 }
1702
1703 if (pProto->RequiredReputationFaction && uint32(GetReputationRank(pProto->RequiredReputationFaction)) < pProto->RequiredReputationRank)
1704 return EQUIP_ERR_CANT_EQUIP_REPUTATION;
1705
1706 return EQUIP_ERR_OK;
1707 }
1708 }
1709 return EQUIP_ERR_ITEM_NOT_FOUND;
1710}
1711
1712InventoryResult Player::CanUseItem(ItemTemplate const* proto) const
1713{
1714 // Used by group, function NeedBeforeGreed, to know if a prototype can be used by a player
1715
1716 if (proto)
1717 {
1718 if ((proto->Flags2 & ITEM_FLAGS_EXTRA_HORDE_ONLY) && GetTeam() != HORDE)
1719 return EQUIP_ERR_CANT_EQUIP_EVER;
1720
1721 if ((proto->Flags2 & ITEM_FLAGS_EXTRA_ALLIANCE_ONLY) && GetTeam() != ALLIANCE)
1722 return EQUIP_ERR_CANT_EQUIP_EVER;
1723
1724 if ((proto->AllowableClass & getClassMask()) == 0 || (proto->AllowableRace & getRaceMask()) == 0)
1725 return EQUIP_ERR_CANT_EQUIP_EVER;
1726
1727 if (proto->RequiredSkill != 0)
1728 {
1729 if (GetSkillValue(proto->RequiredSkill) == 0)
1730 return EQUIP_ERR_PROFICIENCY_NEEDED;
1731 else if (GetSkillValue(proto->RequiredSkill) < proto->RequiredSkillRank)
1732 return EQUIP_ERR_CANT_EQUIP_SKILL;
1733 }
1734
1735 if (proto->RequiredSpell != 0 && !HasSpell(proto->RequiredSpell))
1736 return EQUIP_ERR_PROFICIENCY_NEEDED;
1737
1738 if (getLevel() < proto->RequiredLevel)
1739 return EQUIP_ERR_CANT_EQUIP_LEVEL_I;
1740
1741 // If World Event is not active, prevent using event dependant items
1742 if (proto->HolidayId && !IsHolidayActive((HolidayIds)proto->HolidayId))
1743 return EQUIP_ERR_CLIENT_LOCKED_OUT;
1744
1745 return EQUIP_ERR_OK;
1746 }
1747
1748 return EQUIP_ERR_ITEM_NOT_FOUND;
1749}
1750
1751InventoryResult Player::CanRollForItemInLFG(ItemTemplate const* proto, WorldObject const* lootedObject) const
1752{
1753 if (!GetGroup() || !GetGroup()->isLFGGroup())
1754 return EQUIP_ERR_OK; // not in LFG group
1755
1756 // check if looted object is inside the lfg dungeon
1757 Map const* map = lootedObject->GetMap();
1758 if (!sLFGMgr->inLfgDungeonMap(GetGroup()->GetGUID(), map->GetId(), map->GetDifficulty()))
1759 return EQUIP_ERR_OK;
1760
1761 if (!proto)
1762 return EQUIP_ERR_ITEM_NOT_FOUND;
1763 // Used by group, function NeedBeforeGreed, to know if a prototype can be used by a player
1764
1765 const static uint32 item_weapon_skills[MAX_ITEM_SUBCLASS_WEAPON] =
1766 {
1767 SKILL_AXES, SKILL_2H_AXES, SKILL_BOWS, SKILL_GUNS, SKILL_MACES,
1768 SKILL_2H_MACES, SKILL_POLEARMS, SKILL_SWORDS, SKILL_2H_SWORDS, 0,
1769 SKILL_STAVES, 0, 0, SKILL_FIST_WEAPONS, 0,
1770 SKILL_DAGGERS, 0, 0, SKILL_CROSSBOWS, SKILL_WANDS,
1771 SKILL_FISHING
1772 }; //Copy from function Item::GetSkill()
1773
1774 if ((proto->AllowableClass & getClassMask()) == 0 || (proto->AllowableRace & getRaceMask()) == 0)
1775 return EQUIP_ERR_CANT_EQUIP_EVER;
1776
1777 if (proto->RequiredSpell != 0 && !HasSpell(proto->RequiredSpell))
1778 return EQUIP_ERR_PROFICIENCY_NEEDED;
1779
1780 if (proto->RequiredSkill != 0)
1781 {
1782 if (!GetSkillValue(proto->RequiredSkill))
1783 return EQUIP_ERR_PROFICIENCY_NEEDED;
1784 else if (GetSkillValue(proto->RequiredSkill) < proto->RequiredSkillRank)
1785 return EQUIP_ERR_CANT_EQUIP_SKILL;
1786 }
1787
1788 uint8 _class = getClass();
1789
1790 if (proto->Class == ITEM_CLASS_WEAPON && GetSkillValue(item_weapon_skills[proto->SubClass]) == 0)
1791 return EQUIP_ERR_PROFICIENCY_NEEDED;
1792
1793 if (proto->Class == ITEM_CLASS_ARMOR && proto->SubClass > ITEM_SUBCLASS_ARMOR_MISCELLANEOUS && proto->SubClass < ITEM_SUBCLASS_ARMOR_BUCKLER && proto->InventoryType != INVTYPE_CLOAK)
1794 {
1795 if (_class == CLASS_WARRIOR || _class == CLASS_PALADIN || _class == CLASS_DEATH_KNIGHT)
1796 {
1797 if (getLevel() < 50)
1798 {
1799 if (proto->SubClass != ITEM_SUBCLASS_ARMOR_MAIL)
1800 return EQUIP_ERR_CLIENT_LOCKED_OUT;
1801 }
1802 else if (proto->SubClass != ITEM_SUBCLASS_ARMOR_PLATE)
1803 return EQUIP_ERR_CLIENT_LOCKED_OUT;
1804 }
1805 else if (_class == CLASS_HUNTER || _class == CLASS_SHAMAN)
1806 {
1807 if (getLevel() < 50)
1808 {
1809 if (proto->SubClass != ITEM_SUBCLASS_ARMOR_LEATHER)
1810 return EQUIP_ERR_CLIENT_LOCKED_OUT;
1811 }
1812 else if (proto->SubClass != ITEM_SUBCLASS_ARMOR_MAIL)
1813 return EQUIP_ERR_CLIENT_LOCKED_OUT;
1814 }
1815 else if (_class == CLASS_MONK)
1816 {
1817 if (getLevel() < 50)
1818 {
1819 if (proto->SubClass != ITEM_SUBCLASS_ARMOR_CLOTH)
1820 return EQUIP_ERR_CLIENT_LOCKED_OUT;
1821 }
1822 else if (proto->SubClass != ITEM_SUBCLASS_LEATHER)
1823 return EQUIP_ERR_CLIENT_LOCKED_OUT;
1824 }
1825
1826 if (_class == CLASS_ROGUE || _class == CLASS_DRUID)
1827 if (proto->SubClass != ITEM_SUBCLASS_ARMOR_LEATHER)
1828 return EQUIP_ERR_CLIENT_LOCKED_OUT;
1829
1830 if (_class == CLASS_MAGE || _class == CLASS_PRIEST || _class == CLASS_WARLOCK)
1831 if (proto->SubClass != ITEM_SUBCLASS_ARMOR_CLOTH)
1832 return EQUIP_ERR_CLIENT_LOCKED_OUT;
1833 }
1834
1835 return EQUIP_ERR_OK;
1836}
1837
1838// Return stored item (if stored to stack, it can diff. from pItem). And pItem ca be deleted in this case.
1839Item* Player::StoreNewItem(ItemPosCountVec const& dest, uint32 item, bool update, int32 randomPropertyId, AllowedLooterSet const& allowedLooters)
1840{
1841 uint32 count = 0;
1842 for (ItemPosCountVec::const_iterator itr = dest.begin(); itr != dest.end(); ++itr)
1843 count += itr->count;
1844
1845 Item* pItem = Item::CreateItem(item, count, this);
1846 if (pItem)
1847 {
1848 ItemAddedQuestCheck(item, count);
1849 UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM, item, count);
1850 UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM, item, 1);
1851 if (randomPropertyId)
1852 pItem->SetItemRandomProperties(randomPropertyId);
1853 pItem = StoreItem(dest, pItem, update);
1854
1855 if (allowedLooters.size() > 1 && pItem->GetTemplate()->GetMaxStackSize() == 1 && pItem->IsSoulBound())
1856 {
1857 pItem->SetSoulboundTradeable(allowedLooters);
1858 pItem->SetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME, GetTotalPlayedTime());
1859 AddTradeableItem(pItem);
1860
1861 // save data
1862 std::ostringstream ss;
1863 AllowedLooterSet::const_iterator itr = allowedLooters.begin();
1864 ss << *itr;
1865 for (++itr; itr != allowedLooters.end(); ++itr)
1866 ss << ' ' << *itr;
1867
1868 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ITEM_BOP_TRADE);
1869 stmt->setUInt32(0, pItem->GetGUIDLow());
1870 stmt->setString(1, ss.str());
1871 CharacterDatabase.Execute(stmt);
1872 }
1873 }
1874 return pItem;
1875}
1876
1877Item* Player::StoreItem(ItemPosCountVec const& dest, Item* pItem, bool update)
1878{
1879 if (!pItem)
1880 return NULL;
1881
1882 Item* lastItem = pItem;
1883 for (ItemPosCountVec::const_iterator itr = dest.begin(); itr != dest.end();)
1884 {
1885 uint16 pos = itr->pos;
1886 uint32 count = itr->count;
1887
1888 ++itr;
1889
1890 if (itr == dest.end())
1891 {
1892 lastItem = _StoreItem(pos, pItem, count, false, update);
1893 break;
1894 }
1895
1896 lastItem = _StoreItem(pos, pItem, count, true, update);
1897 }
1898 return lastItem;
1899}
1900
1901// Return stored item (if stored to stack, it can diff. from pItem). And pItem ca be deleted in this case.
1902Item* Player::_StoreItem(uint16 pos, Item* pItem, uint32 count, bool clone, bool update)
1903{
1904 if (!pItem)
1905 return NULL;
1906
1907 uint8 bag = pos >> 8;
1908 uint8 slot = pos & 255;
1909
1910 SF_LOG_DEBUG("entities.player.items", "STORAGE: StoreItem bag = %u, slot = %u, item = %u, count = %u, guid = %u", bag, slot, pItem->GetEntry(), count, pItem->GetGUIDLow());
1911
1912 Item* pItem2 = GetItemByPos(bag, slot);
1913
1914 if (!pItem2)
1915 {
1916 if (clone)
1917 pItem = pItem->CloneItem(count, this);
1918 else
1919 pItem->SetCount(count);
1920
1921 if (!pItem)
1922 return NULL;
1923
1924 if (pItem->GetTemplate()->Bonding == BIND_WHEN_PICKED_UP ||
1925 pItem->GetTemplate()->Bonding == BIND_QUEST_ITEM ||
1926 (pItem->GetTemplate()->Bonding == BIND_WHEN_EQUIPED && IsBagPos(pos)))
1927 pItem->SetBinding(true);
1928
1929 Bag* pBag = (bag == INVENTORY_SLOT_BAG_0) ? NULL : GetBagByPos(bag);
1930 if (!pBag)
1931 {
1932 m_items[slot] = pItem;
1933 SetUInt64Value(PLAYER_FIELD_INV_SLOTS + (slot * 2), pItem->GetGUID());
1934 pItem->SetUInt64Value(ITEM_FIELD_CONTAINED_IN, GetGUID());
1935 pItem->SetUInt64Value(ITEM_FIELD_OWNER, GetGUID());
1936
1937 pItem->SetSlot(slot);
1938 pItem->SetContainer(NULL);
1939 }
1940 else
1941 pBag->StoreItem(slot, pItem, update);
1942
1943 if (IsInWorld() && update)
1944 {
1945 pItem->AddToWorld();
1946 pItem->SendUpdateToPlayer(this);
1947 }
1948
1949 pItem->SetState(ITEM_CHANGED, this);
1950 if (pBag)
1951 pBag->SetState(ITEM_CHANGED, this);
1952
1953 AddEnchantmentDurations(pItem);
1954 AddItemDurations(pItem);
1955
1956 const ItemTemplate* proto = pItem->GetTemplate();
1957 for (uint8 i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
1958 if (proto->Spells[i].SpellTrigger == ITEM_SPELLTRIGGER_ON_NO_DELAY_USE && proto->Spells[i].SpellId > 0) // On obtain trigger
1959 if (bag == INVENTORY_SLOT_BAG_0 || (bag >= INVENTORY_SLOT_BAG_START && bag < INVENTORY_SLOT_BAG_END))
1960 if (!HasAura(proto->Spells[i].SpellId))
1961 CastSpell(this, proto->Spells[i].SpellId, true, pItem);
1962
1963 return pItem;
1964 }
1965 else
1966 {
1967 if (pItem2->GetTemplate()->Bonding == BIND_WHEN_PICKED_UP ||
1968 pItem2->GetTemplate()->Bonding == BIND_QUEST_ITEM ||
1969 (pItem2->GetTemplate()->Bonding == BIND_WHEN_EQUIPED && IsBagPos(pos)))
1970 pItem2->SetBinding(true);
1971
1972 pItem2->SetCount(pItem2->GetCount() + count);
1973 if (IsInWorld() && update)
1974 pItem2->SendUpdateToPlayer(this);
1975
1976 if (!clone)
1977 {
1978 // delete item (it not in any slot currently)
1979 if (IsInWorld() && update)
1980 {
1981 pItem->RemoveFromWorld();
1982 pItem->DestroyForPlayer(this);
1983 }
1984
1985 RemoveEnchantmentDurations(pItem);
1986 RemoveItemDurations(pItem);
1987
1988 pItem->SetOwnerGUID(GetGUID()); // prevent error at next SetState in case trade/mail/buy from vendor
1989 pItem->SetNotRefundable(this);
1990 pItem->ClearSoulboundTradeable(this);
1991 RemoveTradeableItem(pItem);
1992 pItem->SetState(ITEM_REMOVED, this);
1993 }
1994
1995 AddEnchantmentDurations(pItem2);
1996
1997 pItem2->SetState(ITEM_CHANGED, this);
1998
1999 const ItemTemplate* proto = pItem2->GetTemplate();
2000 for (uint8 i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
2001 if (proto->Spells[i].SpellTrigger == ITEM_SPELLTRIGGER_ON_NO_DELAY_USE && proto->Spells[i].SpellId > 0) // On obtain trigger
2002 if (bag == INVENTORY_SLOT_BAG_0 || (bag >= INVENTORY_SLOT_BAG_START && bag < INVENTORY_SLOT_BAG_END))
2003 if (!HasAura(proto->Spells[i].SpellId))
2004 CastSpell(this, proto->Spells[i].SpellId, true, pItem2);
2005
2006 return pItem2;
2007 }
2008}
2009
2010Item* Player::EquipNewItem(uint16 pos, uint32 item, bool update)
2011{
2012 if (Item* pItem = Item::CreateItem(item, 1, this))
2013 {
2014 ItemAddedQuestCheck(item, 1);
2015 UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM, item, 1);
2016 return EquipItem(pos, pItem, update);
2017 }
2018
2019 return NULL;
2020}
2021
2022Item* Player::EquipItem(uint16 pos, Item* pItem, bool update)
2023{
2024 AddEnchantmentDurations(pItem);
2025 AddItemDurations(pItem);
2026
2027 uint8 bag = pos >> 8;
2028 uint8 slot = pos & 255;
2029
2030 Item* pItem2 = GetItemByPos(bag, slot);
2031
2032 if (!pItem2)
2033 {
2034 VisualizeItem(slot, pItem);
2035
2036 if (IsAlive())
2037 {
2038 ItemTemplate const* pProto = pItem->GetTemplate();
2039
2040 // item set bonuses applied only at equip and removed at unequip, and still active for broken items
2041 if (pProto && pProto->ItemSet)
2042 AddItemsSetItem(this, pItem);
2043
2044 _ApplyItemMods(pItem, slot, true);
2045
2046 if (pProto && IsInCombat() && (pProto->Class == ITEM_CLASS_WEAPON || pProto->InventoryType == INVTYPE_RELIC) && m_weaponChangeTimer == 0)
2047 {
2048 uint32 cooldownSpell = getClass() == CLASS_ROGUE ? 6123 : 6119;
2049 SpellInfo const* spellProto = sSpellMgr->GetSpellInfo(cooldownSpell);
2050
2051 if (!spellProto)
2052 SF_LOG_ERROR("entities.player", "Weapon switch cooldown spell %u couldn't be found in Spell.dbc", cooldownSpell);
2053 else
2054 {
2055 m_weaponChangeTimer = spellProto->StartRecoveryTime;
2056
2057 GetGlobalCooldownMgr().AddGlobalCooldown(spellProto, m_weaponChangeTimer);
2058 ObjectGuid guid = GetGUID();
2059
2060 WorldPacket data(SMSG_SPELL_COOLDOWN, 9 + 3 + 8);
2061 data.WriteBit(guid[0]);
2062 data.WriteBit(guid[6]);
2063 data.WriteBit(1); // Missing flags
2064 data.WriteBit(guid[7]);
2065 data.WriteBit(guid[3]);
2066 data.WriteBit(guid[1]);
2067 data.WriteBit(guid[5]);
2068 size_t bitpos = data.bitwpos();
2069 data.WriteBits(1, 21);
2070 data.WriteBit(guid[2]);
2071 data.WriteBit(guid[4]);
2072
2073 data << uint32(cooldownSpell);
2074 data << uint32(0);
2075 data.WriteByteSeq(guid[5]);
2076 data.WriteByteSeq(guid[3]);
2077 data.WriteByteSeq(guid[7]);
2078 data.WriteByteSeq(guid[4]);
2079 data.WriteByteSeq(guid[1]);
2080 data.WriteByteSeq(guid[0]);
2081 data.WriteByteSeq(guid[2]);
2082 data.WriteByteSeq(guid[6]);
2083 GetSession()->SendPacket(&data);
2084 }
2085 }
2086 }
2087
2088 if (IsInWorld() && update)
2089 {
2090 pItem->AddToWorld();
2091 pItem->SendUpdateToPlayer(this);
2092 }
2093
2094 ApplyEquipCooldown(pItem);
2095
2096 // update expertise and armor penetration - passive auras may need it
2097
2098 if (slot == EQUIPMENT_SLOT_MAINHAND)
2099 UpdateExpertise(WeaponAttackType::BASE_ATTACK);
2100
2101 else if (slot == EQUIPMENT_SLOT_OFFHAND)
2102 UpdateExpertise(WeaponAttackType::OFF_ATTACK);
2103
2104 switch (slot)
2105 {
2106 case EQUIPMENT_SLOT_MAINHAND:
2107 case EQUIPMENT_SLOT_OFFHAND:
2108 {
2109 RecalculateRating(CombatRating::CR_ARMOR_PENETRATION);
2110 break;
2111 }
2112 default:
2113 break;
2114 }
2115 }
2116 else
2117 {
2118 pItem2->SetCount(pItem2->GetCount() + pItem->GetCount());
2119 if (IsInWorld() && update)
2120 pItem2->SendUpdateToPlayer(this);
2121
2122 // delete item (it not in any slot currently)
2123 //pItem->DeleteFromDB();
2124 if (IsInWorld() && update)
2125 {
2126 pItem->RemoveFromWorld();
2127 pItem->DestroyForPlayer(this);
2128 }
2129
2130 RemoveEnchantmentDurations(pItem);
2131 RemoveItemDurations(pItem);
2132
2133 pItem->SetOwnerGUID(GetGUID()); // prevent error at next SetState in case trade/mail/buy from vendor
2134 pItem->SetNotRefundable(this);
2135 pItem->ClearSoulboundTradeable(this);
2136 RemoveTradeableItem(pItem);
2137 pItem->SetState(ITEM_REMOVED, this);
2138 pItem2->SetState(ITEM_CHANGED, this);
2139
2140 ApplyEquipCooldown(pItem2);
2141
2142 return pItem2;
2143 }
2144
2145 // only for full equip instead adding to stack
2146 UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM, pItem->GetEntry());
2147 UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM, pItem->GetEntry(), slot);
2148
2149 return pItem;
2150}
2151
2152void Player::QuickEquipItem(uint16 pos, Item* pItem)
2153{
2154 if (pItem)
2155 {
2156 AddEnchantmentDurations(pItem);
2157 AddItemDurations(pItem);
2158
2159 uint8 slot = pos & 255;
2160 VisualizeItem(slot, pItem);
2161
2162 if (IsInWorld())
2163 {
2164 pItem->AddToWorld();
2165 pItem->SendUpdateToPlayer(this);
2166 }
2167
2168 UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM, pItem->GetEntry());
2169 UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM, pItem->GetEntry(), slot);
2170 }
2171}
2172
2173void Player::SetVisibleItemSlot(uint8 slot, Item* pItem)
2174{
2175 if (pItem)
2176 {
2177 SetUInt32Value(PLAYER_FIELD_VISIBLE_ITEMS + (slot * 2), pItem->GetVisibleEntry());
2178 SetUInt16Value(PLAYER_FIELD_VISIBLE_ITEMS + 1 + (slot * 2), 0, pItem->GetEnchantmentId(PERM_ENCHANTMENT_SLOT));
2179 SetUInt16Value(PLAYER_FIELD_VISIBLE_ITEMS + 1 + (slot * 2), 1, pItem->GetEnchantmentId(TEMP_ENCHANTMENT_SLOT));
2180 }
2181 else
2182 {
2183 SetUInt32Value(PLAYER_FIELD_VISIBLE_ITEMS + (slot * 2), 0);
2184 SetUInt32Value(PLAYER_FIELD_VISIBLE_ITEMS + 1 + (slot * 2), 0);
2185 }
2186}
2187
2188void Player::VisualizeItem(uint8 slot, Item* pItem)
2189{
2190 if (!pItem)
2191 return;
2192
2193 // check also BIND_WHEN_PICKED_UP and BIND_QUEST_ITEM for .additem or .additemset case by GM (not binded at adding to inventory)
2194 if (pItem->GetTemplate()->Bonding == BIND_WHEN_EQUIPED || pItem->GetTemplate()->Bonding == BIND_WHEN_PICKED_UP || pItem->GetTemplate()->Bonding == BIND_QUEST_ITEM)
2195 pItem->SetBinding(true);
2196
2197 SF_LOG_DEBUG("entities.player.items", "STORAGE: EquipItem slot = %u, item = %u", slot, pItem->GetEntry());
2198
2199 m_items[slot] = pItem;
2200 SetUInt64Value(PLAYER_FIELD_INV_SLOTS + (slot * 2), pItem->GetGUID());
2201 pItem->SetUInt64Value(ITEM_FIELD_CONTAINED_IN, GetGUID());
2202 pItem->SetUInt64Value(ITEM_FIELD_OWNER, GetGUID());
2203 pItem->SetSlot(slot);
2204 pItem->SetContainer(NULL);
2205
2206 if (slot < EQUIPMENT_SLOT_END)
2207 SetVisibleItemSlot(slot, pItem);
2208
2209 pItem->SetState(ITEM_CHANGED, this);
2210}
2211
2212Item* Player::BankItem(ItemPosCountVec const& dest, Item* pItem, bool update)
2213{
2214 return StoreItem(dest, pItem, update);
2215}
2216
2217void Player::RemoveItem(uint8 bag, uint8 slot, bool update)
2218{
2219 // note: removeitem does not actually change the item
2220 // it only takes the item out of storage temporarily
2221 // note2: if removeitem is to be used for delinking
2222 // the item must be removed from the player's updatequeue
2223
2224 Item* pItem = GetItemByPos(bag, slot);
2225 if (pItem)
2226 {
2227 SF_LOG_DEBUG("entities.player.items", "STORAGE: RemoveItem bag = %u, slot = %u, item = %u", bag, slot, pItem->GetEntry());
2228
2229 RemoveEnchantmentDurations(pItem);
2230 RemoveItemDurations(pItem);
2231 RemoveTradeableItem(pItem);
2232
2233 if (bag == INVENTORY_SLOT_BAG_0)
2234 {
2235 if (slot < INVENTORY_SLOT_BAG_END)
2236 {
2237 ItemTemplate const* pProto = pItem->GetTemplate();
2238 // item set bonuses applied only at equip and removed at unequip, and still active for broken items
2239
2240 if (pProto && pProto->ItemSet)
2241 RemoveItemsSetItem(this, pProto);
2242
2243 _ApplyItemMods(pItem, slot, false);
2244
2245 // remove item dependent auras and casts (only weapon and armor slots)
2246 if (slot < EQUIPMENT_SLOT_END)
2247 {
2248 RemoveItemDependentAurasAndCasts(pItem);
2249
2250 // remove held enchantments, update expertise
2251 if (slot == EQUIPMENT_SLOT_MAINHAND)
2252 {
2253 if (pItem->GetItemSuffixFactor())
2254 {
2255 pItem->ClearEnchantment(PROP_ENCHANTMENT_SLOT_3);
2256 pItem->ClearEnchantment(PROP_ENCHANTMENT_SLOT_4);
2257 }
2258 else
2259 {
2260 pItem->ClearEnchantment(PROP_ENCHANTMENT_SLOT_0);
2261 pItem->ClearEnchantment(PROP_ENCHANTMENT_SLOT_1);
2262 }
2263
2264 UpdateExpertise(WeaponAttackType::BASE_ATTACK);
2265 }
2266 else if (slot == EQUIPMENT_SLOT_OFFHAND)
2267 UpdateExpertise(WeaponAttackType::OFF_ATTACK);
2268 // update armor penetration - passive auras may need it
2269 switch (slot)
2270 {
2271 case EQUIPMENT_SLOT_MAINHAND:
2272 case EQUIPMENT_SLOT_OFFHAND:
2273 {
2274 RecalculateRating(CombatRating::CR_ARMOR_PENETRATION);
2275 break;
2276 }
2277 default:
2278 break;
2279 }
2280 }
2281 }
2282
2283 m_items[slot] = NULL;
2284 SetUInt64Value(PLAYER_FIELD_INV_SLOTS + (slot * 2), 0);
2285
2286 if (slot < EQUIPMENT_SLOT_END)
2287 SetVisibleItemSlot(slot, NULL);
2288 }
2289 else if (Bag* pBag = GetBagByPos(bag))
2290 pBag->RemoveItem(slot, update);
2291
2292 pItem->SetUInt64Value(ITEM_FIELD_CONTAINED_IN, 0);
2293 // pItem->SetUInt64Value(ITEM_FIELD_OWNER, 0); not clear owner at remove (it will be set at store). This used in mail and auction code
2294 pItem->SetSlot(NULL_SLOT);
2295 if (IsInWorld() && update)
2296 pItem->SendUpdateToPlayer(this);
2297 }
2298}
2299
2300// Common operation need to remove item from inventory without delete in trade, auction, guild bank, mail....
2301void Player::MoveItemFromInventory(uint8 bag, uint8 slot, bool update)
2302{
2303 if (Item* it = GetItemByPos(bag, slot))
2304 {
2305 ItemRemovedQuestCheck(it->GetEntry(), it->GetCount());
2306 RemoveItem(bag, slot, update);
2307 it->SetNotRefundable(this, false);
2308 it->RemoveFromUpdateQueueOf(this);
2309 if (it->IsInWorld())
2310 {
2311 it->RemoveFromWorld();
2312 it->DestroyForPlayer(this);
2313 }
2314 }
2315}
2316
2317// Common operation need to add item from inventory without delete in trade, guild bank, mail....
2318void Player::MoveItemToInventory(ItemPosCountVec const& dest, Item* pItem, bool update, bool in_characterInventoryDB)
2319{
2320 // update quest counters
2321 ItemAddedQuestCheck(pItem->GetEntry(), pItem->GetCount());
2322 UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM, pItem->GetEntry(), pItem->GetCount());
2323
2324 // store item
2325 Item* pLastItem = StoreItem(dest, pItem, update);
2326
2327 // only set if not merged to existed stack (pItem can be deleted already but we can compare pointers any way)
2328 if (pLastItem == pItem)
2329 {
2330 // update owner for last item (this can be original item with wrong owner
2331 if (pLastItem->GetOwnerGUID() != GetGUID())
2332 pLastItem->SetOwnerGUID(GetGUID());
2333
2334 // if this original item then it need create record in inventory
2335 // in case trade we already have item in other player inventory
2336 pLastItem->SetState(in_characterInventoryDB ? ITEM_CHANGED : ITEM_NEW, this);
2337
2338 if (pLastItem->HasFlag(ITEM_FIELD_DYNAMIC_FLAGS, ITEM_FLAG_BOP_TRADEABLE))
2339 AddTradeableItem(pLastItem);
2340 }
2341}
2342
2343void Player::DestroyItem(uint8 bag, uint8 slot, bool update)
2344{
2345 Item* pItem = GetItemByPos(bag, slot);
2346 if (pItem)
2347 {
2348 SF_LOG_DEBUG("entities.player.items", "STORAGE: DestroyItem bag = %u, slot = %u, item = %u", bag, slot, pItem->GetEntry());
2349 // Also remove all contained items if the item is a bag.
2350 // This if () prevents item saving crashes if the condition for a bag to be empty before being destroyed was bypassed somehow.
2351 if (pItem->IsNotEmptyBag())
2352 for (uint8 i = 0; i < MAX_BAG_SIZE; ++i)
2353 DestroyItem(slot, i, update);
2354
2355 if (pItem->HasFlag(ITEM_FIELD_DYNAMIC_FLAGS, ITEM_FLAG_WRAPPED))
2356 {
2357 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GIFT);
2358
2359 stmt->setUInt32(0, pItem->GetGUIDLow());
2360
2361 CharacterDatabase.Execute(stmt);
2362 }
2363
2364 RemoveEnchantmentDurations(pItem);
2365 RemoveItemDurations(pItem);
2366
2367 pItem->SetNotRefundable(this);
2368 pItem->ClearSoulboundTradeable(this);
2369 RemoveTradeableItem(pItem);
2370
2371 const ItemTemplate* proto = pItem->GetTemplate();
2372 for (uint8 i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
2373 if (proto->Spells[i].SpellTrigger == ITEM_SPELLTRIGGER_ON_NO_DELAY_USE && proto->Spells[i].SpellId > 0) // On obtain trigger
2374 RemoveAurasDueToSpell(proto->Spells[i].SpellId);
2375
2376 ItemRemovedQuestCheck(pItem->GetEntry(), pItem->GetCount());
2377
2378 if (bag == INVENTORY_SLOT_BAG_0)
2379 {
2380 SetUInt64Value(PLAYER_FIELD_INV_SLOTS + (slot * 2), 0);
2381
2382 // equipment and equipped bags can have applied bonuses
2383 if (slot < INVENTORY_SLOT_BAG_END)
2384 {
2385 ItemTemplate const* pProto = pItem->GetTemplate();
2386
2387 // item set bonuses applied only at equip and removed at unequip, and still active for broken items
2388 if (pProto && pProto->ItemSet)
2389 RemoveItemsSetItem(this, pProto);
2390
2391 _ApplyItemMods(pItem, slot, false);
2392 }
2393
2394 if (slot < EQUIPMENT_SLOT_END)
2395 {
2396 // remove item dependent auras and casts (only weapon and armor slots)
2397 RemoveItemDependentAurasAndCasts(pItem);
2398
2399 // update expertise and armor penetration - passive auras may need it
2400 switch (slot)
2401 {
2402 case EQUIPMENT_SLOT_MAINHAND:
2403 case EQUIPMENT_SLOT_OFFHAND:
2404 {
2405 RecalculateRating(CombatRating::CR_ARMOR_PENETRATION);
2406 break;
2407 }
2408 default:
2409 break;
2410 }
2411
2412 if (slot == EQUIPMENT_SLOT_MAINHAND)
2413 UpdateExpertise(WeaponAttackType::BASE_ATTACK);
2414 else if (slot == EQUIPMENT_SLOT_OFFHAND)
2415 UpdateExpertise(WeaponAttackType::OFF_ATTACK);
2416
2417 // equipment visual show
2418 SetVisibleItemSlot(slot, NULL);
2419 }
2420
2421 m_items[slot] = NULL;
2422 }
2423 else if (Bag* pBag = GetBagByPos(bag))
2424 pBag->RemoveItem(slot, update);
2425
2426 // Delete rolled money / loot from db.
2427 // MUST be done before RemoveFromWorld() or GetTemplate() fails
2428 if (ItemTemplate const* pTmp = pItem->GetTemplate())
2429 if (pTmp->Flags & ITEM_PROTO_FLAG_OPENABLE)
2430 pItem->ItemContainerDeleteLootMoneyAndLootItemsFromDB();
2431
2432 if (IsInWorld() && update)
2433 {
2434 pItem->RemoveFromWorld();
2435 pItem->DestroyForPlayer(this);
2436 }
2437
2438 //pItem->SetOwnerGUID(0);
2439 pItem->SetUInt64Value(ITEM_FIELD_CONTAINED_IN, 0);
2440 pItem->SetSlot(NULL_SLOT);
2441 pItem->SetState(ITEM_REMOVED, this);
2442 }
2443}
2444
2445void Player::DestroyItemCount(uint32 itemEntry, uint32 count, bool update, bool unequip_check)
2446{
2447 SF_LOG_DEBUG("entities.player.items", "STORAGE: DestroyItemCount item = %u, count = %u", itemEntry, count);
2448 uint32 remcount = 0;
2449
2450 // in inventory
2451 for (uint8 i = INVENTORY_SLOT_ITEM_START; i < INVENTORY_SLOT_ITEM_END; ++i)
2452 {
2453 if (Item* item = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
2454 {
2455 if (item->GetEntry() == itemEntry && !item->IsInTrade())
2456 {
2457 if (item->GetCount() + remcount <= count)
2458 {
2459 // all items in inventory can unequipped
2460 remcount += item->GetCount();
2461 DestroyItem(INVENTORY_SLOT_BAG_0, i, update);
2462
2463 if (remcount >= count)
2464 return;
2465 }
2466 else
2467 {
2468 ItemRemovedQuestCheck(item->GetEntry(), count - remcount);
2469 item->SetCount(item->GetCount() - count + remcount);
2470 if (IsInWorld() && update)
2471 item->SendUpdateToPlayer(this);
2472 item->SetState(ITEM_CHANGED, this);
2473 return;
2474 }
2475 }
2476 }
2477 }
2478
2479 // in inventory bags
2480 for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
2481 {
2482 if (Bag* bag = GetBagByPos(i))
2483 {
2484 for (uint32 j = 0; j < bag->GetBagSize(); j++)
2485 {
2486 if (Item* item = bag->GetItemByPos(j))
2487 {
2488 if (item->GetEntry() == itemEntry && !item->IsInTrade())
2489 {
2490 // all items in bags can be unequipped
2491 if (item->GetCount() + remcount <= count)
2492 {
2493 remcount += item->GetCount();
2494 DestroyItem(i, j, update);
2495
2496 if (remcount >= count)
2497 return;
2498 }
2499 else
2500 {
2501 ItemRemovedQuestCheck(item->GetEntry(), count - remcount);
2502 item->SetCount(item->GetCount() - count + remcount);
2503 if (IsInWorld() && update)
2504 item->SendUpdateToPlayer(this);
2505 item->SetState(ITEM_CHANGED, this);
2506 return;
2507 }
2508 }
2509 }
2510 }
2511 }
2512 }
2513
2514 // in equipment and bag list
2515 for (uint8 i = EQUIPMENT_SLOT_START; i < INVENTORY_SLOT_BAG_END; i++)
2516 {
2517 if (Item* item = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
2518 {
2519 if (item && item->GetEntry() == itemEntry && !item->IsInTrade())
2520 {
2521 if (item->GetCount() + remcount <= count)
2522 {
2523 if (!unequip_check || CanUnequipItem(INVENTORY_SLOT_BAG_0 << 8 | i, false) == EQUIP_ERR_OK)
2524 {
2525 remcount += item->GetCount();
2526 DestroyItem(INVENTORY_SLOT_BAG_0, i, update);
2527
2528 if (remcount >= count)
2529 return;
2530 }
2531 }
2532 else
2533 {
2534 ItemRemovedQuestCheck(item->GetEntry(), count - remcount);
2535 item->SetCount(item->GetCount() - count + remcount);
2536 if (IsInWorld() && update)
2537 item->SendUpdateToPlayer(this);
2538 item->SetState(ITEM_CHANGED, this);
2539 return;
2540 }
2541 }
2542 }
2543 }
2544
2545 // in bank
2546 for (uint8 i = BANK_SLOT_ITEM_START; i < BANK_SLOT_ITEM_END; i++)
2547 {
2548 if (Item* item = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
2549 {
2550 if (item->GetEntry() == itemEntry && !item->IsInTrade())
2551 {
2552 if (item->GetCount() + remcount <= count)
2553 {
2554 remcount += item->GetCount();
2555 DestroyItem(INVENTORY_SLOT_BAG_0, i, update);
2556 if (remcount >= count)
2557 return;
2558 }
2559 else
2560 {
2561 ItemRemovedQuestCheck(item->GetEntry(), count - remcount);
2562 item->SetCount(item->GetCount() - count + remcount);
2563 if (IsInWorld() && update)
2564 item->SendUpdateToPlayer(this);
2565 item->SetState(ITEM_CHANGED, this);
2566 return;
2567 }
2568 }
2569 }
2570 }
2571
2572 // in bank bags
2573 for (uint8 i = BANK_SLOT_BAG_START; i < BANK_SLOT_BAG_END; i++)
2574 {
2575 if (Bag* bag = GetBagByPos(i))
2576 {
2577 for (uint32 j = 0; j < bag->GetBagSize(); j++)
2578 {
2579 if (Item* item = bag->GetItemByPos(j))
2580 {
2581 if (item->GetEntry() == itemEntry && !item->IsInTrade())
2582 {
2583 // all items in bags can be unequipped
2584 if (item->GetCount() + remcount <= count)
2585 {
2586 remcount += item->GetCount();
2587 DestroyItem(i, j, update);
2588
2589 if (remcount >= count)
2590 return;
2591 }
2592 else
2593 {
2594 ItemRemovedQuestCheck(item->GetEntry(), count - remcount);
2595 item->SetCount(item->GetCount() - count + remcount);
2596 if (IsInWorld() && update)
2597 item->SendUpdateToPlayer(this);
2598 item->SetState(ITEM_CHANGED, this);
2599 return;
2600 }
2601 }
2602 }
2603 }
2604 }
2605 }
2606}
2607
2608void Player::DestroyZoneLimitedItem(bool update, uint32 new_zone)
2609{
2610 SF_LOG_DEBUG("entities.player.items", "STORAGE: DestroyZoneLimitedItem in map %u and area %u", GetMapId(), new_zone);
2611
2612 // in inventory
2613 for (uint8 i = INVENTORY_SLOT_ITEM_START; i < INVENTORY_SLOT_ITEM_END; i++)
2614 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
2615 if (pItem->IsLimitedToAnotherMapOrZone(GetMapId(), new_zone))
2616 DestroyItem(INVENTORY_SLOT_BAG_0, i, update);
2617
2618 // in inventory bags
2619 for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
2620 if (Bag* pBag = GetBagByPos(i))
2621 for (uint32 j = 0; j < pBag->GetBagSize(); j++)
2622 if (Item* pItem = pBag->GetItemByPos(j))
2623 if (pItem->IsLimitedToAnotherMapOrZone(GetMapId(), new_zone))
2624 DestroyItem(i, j, update);
2625
2626 // in equipment and bag list
2627 for (uint8 i = EQUIPMENT_SLOT_START; i < INVENTORY_SLOT_BAG_END; i++)
2628 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
2629 if (pItem->IsLimitedToAnotherMapOrZone(GetMapId(), new_zone))
2630 DestroyItem(INVENTORY_SLOT_BAG_0, i, update);
2631}
2632
2633void Player::DestroyConjuredItems(bool update)
2634{
2635 // used when entering arena
2636 // destroys all conjured items
2637 SF_LOG_DEBUG("entities.player.items", "STORAGE: DestroyConjuredItems");
2638
2639 // in inventory
2640 for (uint8 i = INVENTORY_SLOT_ITEM_START; i < INVENTORY_SLOT_ITEM_END; i++)
2641 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
2642 if (pItem->IsConjuredConsumable())
2643 DestroyItem(INVENTORY_SLOT_BAG_0, i, update);
2644
2645 // in inventory bags
2646 for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
2647 if (Bag* pBag = GetBagByPos(i))
2648 for (uint32 j = 0; j < pBag->GetBagSize(); j++)
2649 if (Item* pItem = pBag->GetItemByPos(j))
2650 if (pItem->IsConjuredConsumable())
2651 DestroyItem(i, j, update);
2652
2653 // in equipment and bag list
2654 for (uint8 i = EQUIPMENT_SLOT_START; i < INVENTORY_SLOT_BAG_END; i++)
2655 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
2656 if (pItem->IsConjuredConsumable())
2657 DestroyItem(INVENTORY_SLOT_BAG_0, i, update);
2658}
2659
2660Item* Player::GetItemByEntry(uint32 entry) const
2661{
2662 // in inventory
2663 for (int i = INVENTORY_SLOT_ITEM_START; i < INVENTORY_SLOT_ITEM_END; ++i)
2664 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
2665 if (pItem->GetEntry() == entry)
2666 return pItem;
2667
2668 for (int i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; ++i)
2669 if (Bag* pBag = GetBagByPos(i))
2670 for (uint32 j = 0; j < pBag->GetBagSize(); ++j)
2671 if (Item* pItem = pBag->GetItemByPos(j))
2672 if (pItem->GetEntry() == entry)
2673 return pItem;
2674
2675 for (int i = EQUIPMENT_SLOT_START; i < INVENTORY_SLOT_BAG_END; ++i)
2676 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
2677 if (pItem->GetEntry() == entry)
2678 return pItem;
2679
2680 return NULL;
2681}
2682
2683void Player::DestroyItemCount(Item* pItem, uint32& count, bool update)
2684{
2685 if (!pItem)
2686 return;
2687
2688 SF_LOG_DEBUG("entities.player.items", "STORAGE: DestroyItemCount item (GUID: %u, Entry: %u) count = %u", pItem->GetGUIDLow(), pItem->GetEntry(), count);
2689
2690 if (pItem->GetCount() <= count)
2691 {
2692 count -= pItem->GetCount();
2693
2694 DestroyItem(pItem->GetBagSlot(), pItem->GetSlot(), update);
2695 }
2696 else
2697 {
2698 ItemRemovedQuestCheck(pItem->GetEntry(), count);
2699 pItem->SetCount(pItem->GetCount() - count);
2700 count = 0;
2701 if (IsInWorld() && update)
2702 pItem->SendUpdateToPlayer(this);
2703 pItem->SetState(ITEM_CHANGED, this);
2704 }
2705}
2706
2707void Player::SplitItem(uint16 src, uint16 dst, uint32 count)
2708{
2709 uint8 srcbag = src >> 8;
2710 uint8 srcslot = src & 255;
2711
2712 uint8 dstbag = dst >> 8;
2713 uint8 dstslot = dst & 255;
2714
2715 Item* pSrcItem = GetItemByPos(srcbag, srcslot);
2716 if (!pSrcItem)
2717 {
2718 SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pSrcItem, NULL);
2719 return;
2720 }
2721
2722 if (pSrcItem->m_lootGenerated) // prevent split looting item (item
2723 {
2724 //best error message found for attempting to split while looting
2725 SendEquipError(EQUIP_ERR_SPLIT_FAILED, pSrcItem, NULL);
2726 return;
2727 }
2728
2729 // not let split all items (can be only at cheating)
2730 if (pSrcItem->GetCount() == count)
2731 {
2732 SendEquipError(EQUIP_ERR_SPLIT_FAILED, pSrcItem, NULL);
2733 return;
2734 }
2735
2736 // not let split more existed items (can be only at cheating)
2737 if (pSrcItem->GetCount() < count)
2738 {
2739 SendEquipError(EQUIP_ERR_TOO_FEW_TO_SPLIT, pSrcItem, NULL);
2740 return;
2741 }
2742
2744 if (TradeData* tradeData = GetTradeData())
2745 {
2747 if (tradeData->GetTradeSlotForItem(pSrcItem->GetGUID()) != TRADE_SLOT_INVALID)
2748 return;
2749 }
2750
2751 SF_LOG_DEBUG("entities.player.items", "STORAGE: SplitItem bag = %u, slot = %u, item = %u, count = %u", dstbag, dstslot, pSrcItem->GetEntry(), count);
2752 Item* pNewItem = pSrcItem->CloneItem(count, this);
2753 if (!pNewItem)
2754 {
2755 SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pSrcItem, NULL);
2756 return;
2757 }
2758
2759 if (IsInventoryPos(dst))
2760 {
2761 // change item amount before check (for unique max count check)
2762 pSrcItem->SetCount(pSrcItem->GetCount() - count);
2763
2764 ItemPosCountVec dest;
2765 InventoryResult msg = CanStoreItem(dstbag, dstslot, dest, pNewItem, false);
2766 if (msg != EQUIP_ERR_OK)
2767 {
2768 delete pNewItem;
2769 pSrcItem->SetCount(pSrcItem->GetCount() + count);
2770 SendEquipError(msg, pSrcItem, NULL);
2771 return;
2772 }
2773
2774 if (IsInWorld())
2775 pSrcItem->SendUpdateToPlayer(this);
2776 pSrcItem->SetState(ITEM_CHANGED, this);
2777 StoreItem(dest, pNewItem, true);
2778 }
2779 else if (IsBankPos(dst))
2780 {
2781 // change item amount before check (for unique max count check)
2782 pSrcItem->SetCount(pSrcItem->GetCount() - count);
2783
2784 ItemPosCountVec dest;
2785 InventoryResult msg = CanBankItem(dstbag, dstslot, dest, pNewItem, false);
2786 if (msg != EQUIP_ERR_OK)
2787 {
2788 delete pNewItem;
2789 pSrcItem->SetCount(pSrcItem->GetCount() + count);
2790 SendEquipError(msg, pSrcItem, NULL);
2791 return;
2792 }
2793
2794 if (IsInWorld())
2795 pSrcItem->SendUpdateToPlayer(this);
2796 pSrcItem->SetState(ITEM_CHANGED, this);
2797 BankItem(dest, pNewItem, true);
2798 }
2799 else if (IsEquipmentPos(dst))
2800 {
2801 // change item amount before check (for unique max count check), provide space for splitted items
2802 pSrcItem->SetCount(pSrcItem->GetCount() - count);
2803
2804 uint16 dest;
2805 InventoryResult msg = CanEquipItem(dstslot, dest, pNewItem, false);
2806 if (msg != EQUIP_ERR_OK)
2807 {
2808 delete pNewItem;
2809 pSrcItem->SetCount(pSrcItem->GetCount() + count);
2810 SendEquipError(msg, pSrcItem, NULL);
2811 return;
2812 }
2813
2814 if (IsInWorld())
2815 pSrcItem->SendUpdateToPlayer(this);
2816 pSrcItem->SetState(ITEM_CHANGED, this);
2817 EquipItem(dest, pNewItem, true);
2818 AutoUnequipOffhandIfNeed();
2819 }
2820}
2821
2822void Player::SwapItem(uint16 src, uint16 dst)
2823{
2824 uint8 srcbag = src >> 8;
2825 uint8 srcslot = src & 255;
2826
2827 uint8 dstbag = dst >> 8;
2828 uint8 dstslot = dst & 255;
2829
2830 Item* pSrcItem = GetItemByPos(srcbag, srcslot);
2831 Item* pDstItem = GetItemByPos(dstbag, dstslot);
2832
2833 if (!pSrcItem)
2834 return;
2835
2836 SF_LOG_DEBUG("entities.player.items", "STORAGE: SwapItem bag = %u, slot = %u, item = %u", dstbag, dstslot, pSrcItem->GetEntry());
2837
2838 if (!IsAlive())
2839 {
2840 SendEquipError(EQUIP_ERR_PLAYER_DEAD, pSrcItem, pDstItem);
2841 return;
2842 }
2843
2844 // SRC checks
2845
2846 if (pSrcItem->m_lootGenerated) // prevent swap looting item
2847 {
2848 //best error message found for attempting to swap while looting
2849 SendEquipError(EQUIP_ERR_CLIENT_LOCKED_OUT, pSrcItem, NULL);
2850 return;
2851 }
2852
2853 // check unequip potability for equipped items and bank bags
2854 if (IsEquipmentPos(src) || IsBagPos(src))
2855 {
2856 // bags can be swapped with empty bag slots, or with empty bag (items move possibility checked later)
2857 InventoryResult msg = CanUnequipItem(src, !IsBagPos(src) || IsBagPos(dst) || (pDstItem && pDstItem->ToBag() && pDstItem->ToBag()->IsEmpty()));
2858 if (msg != EQUIP_ERR_OK)
2859 {
2860 SendEquipError(msg, pSrcItem, pDstItem);
2861 return;
2862 }
2863 }
2864
2865 // prevent put equipped/bank bag in self
2866 if (IsBagPos(src) && srcslot == dstbag)
2867 {
2868 SendEquipError(EQUIP_ERR_BAG_IN_BAG, pSrcItem, pDstItem);
2869 return;
2870 }
2871
2872 // prevent equipping bag in the same slot from its inside
2873 if (IsBagPos(dst) && srcbag == dstslot)
2874 {
2875 SendEquipError(EQUIP_ERR_CANT_SWAP, pSrcItem, pDstItem);
2876 return;
2877 }
2878
2879 // DST checks
2880
2881 if (pDstItem)
2882 {
2883 if (pDstItem->m_lootGenerated) // prevent swap looting item
2884 {
2885 //best error message found for attempting to swap while looting
2886 SendEquipError(EQUIP_ERR_CLIENT_LOCKED_OUT, pDstItem, NULL);
2887 return;
2888 }
2889
2890 // check unequip potability for equipped items and bank bags
2891 if (IsEquipmentPos(dst) || IsBagPos(dst))
2892 {
2893 // bags can be swapped with empty bag slots, or with empty bag (items move possibility checked later)
2894 InventoryResult msg = CanUnequipItem(dst, !IsBagPos(dst) || IsBagPos(src) || (pSrcItem->ToBag() && pSrcItem->ToBag()->IsEmpty()));
2895 if (msg != EQUIP_ERR_OK)
2896 {
2897 SendEquipError(msg, pSrcItem, pDstItem);
2898 return;
2899 }
2900 }
2901 }
2902
2903 // NOW this is or item move (swap with empty), or swap with another item (including bags in bag possitions)
2904 // or swap empty bag with another empty or not empty bag (with items exchange)
2905
2906 // Move case
2907 if (!pDstItem)
2908 {
2909 if (IsInventoryPos(dst))
2910 {
2911 ItemPosCountVec dest;
2912 InventoryResult msg = CanStoreItem(dstbag, dstslot, dest, pSrcItem, false);
2913 if (msg != EQUIP_ERR_OK)
2914 {
2915 SendEquipError(msg, pSrcItem, NULL);
2916 return;
2917 }
2918
2919 RemoveItem(srcbag, srcslot, true);
2920 StoreItem(dest, pSrcItem, true);
2921 if (IsBankPos(src))
2922 ItemAddedQuestCheck(pSrcItem->GetEntry(), pSrcItem->GetCount());
2923 }
2924 else if (IsBankPos(dst))
2925 {
2926 ItemPosCountVec dest;
2927 InventoryResult msg = CanBankItem(dstbag, dstslot, dest, pSrcItem, false);
2928 if (msg != EQUIP_ERR_OK)
2929 {
2930 SendEquipError(msg, pSrcItem, NULL);
2931 return;
2932 }
2933
2934 RemoveItem(srcbag, srcslot, true);
2935 BankItem(dest, pSrcItem, true);
2936 ItemRemovedQuestCheck(pSrcItem->GetEntry(), pSrcItem->GetCount());
2937 }
2938 else if (IsEquipmentPos(dst))
2939 {
2940 uint16 dest;
2941 InventoryResult msg = CanEquipItem(dstslot, dest, pSrcItem, false);
2942 if (msg != EQUIP_ERR_OK)
2943 {
2944 SendEquipError(msg, pSrcItem, NULL);
2945 return;
2946 }
2947
2948 RemoveItem(srcbag, srcslot, true);
2949 EquipItem(dest, pSrcItem, true);
2950 AutoUnequipOffhandIfNeed();
2951 }
2952
2953 return;
2954 }
2955
2956 // attempt merge to / fill target item
2957 if (!pSrcItem->IsBag() && !pDstItem->IsBag())
2958 {
2959 InventoryResult msg;
2960 ItemPosCountVec sDest;
2961 uint16 eDest = 0;
2962 if (IsInventoryPos(dst))
2963 msg = CanStoreItem(dstbag, dstslot, sDest, pSrcItem, false);
2964 else if (IsBankPos(dst))
2965 msg = CanBankItem(dstbag, dstslot, sDest, pSrcItem, false);
2966 else if (IsEquipmentPos(dst))
2967 msg = CanEquipItem(dstslot, eDest, pSrcItem, false);
2968 else
2969 return;
2970
2971 // can be merge/fill
2972 if (msg == EQUIP_ERR_OK)
2973 {
2974 if (pSrcItem->GetCount() + pDstItem->GetCount() <= pSrcItem->GetTemplate()->GetMaxStackSize())
2975 {
2976 RemoveItem(srcbag, srcslot, true);
2977
2978 if (IsInventoryPos(dst))
2979 StoreItem(sDest, pSrcItem, true);
2980 else if (IsBankPos(dst))
2981 BankItem(sDest, pSrcItem, true);
2982 else if (IsEquipmentPos(dst))
2983 {
2984 EquipItem(eDest, pSrcItem, true);
2985 AutoUnequipOffhandIfNeed();
2986 }
2987 }
2988 else
2989 {
2990 pSrcItem->SetCount(pSrcItem->GetCount() + pDstItem->GetCount() - pSrcItem->GetTemplate()->GetMaxStackSize());
2991 pDstItem->SetCount(pSrcItem->GetTemplate()->GetMaxStackSize());
2992 pSrcItem->SetState(ITEM_CHANGED, this);
2993 pDstItem->SetState(ITEM_CHANGED, this);
2994 if (IsInWorld())
2995 {
2996 pSrcItem->SendUpdateToPlayer(this);
2997 pDstItem->SendUpdateToPlayer(this);
2998 }
2999 }
3000 SendRefundInfo(pDstItem);
3001 return;
3002 }
3003 }
3004
3005 // impossible merge/fill, do real swap
3006 InventoryResult msg = EQUIP_ERR_OK;
3007
3008 // check src->dest move possibility
3009 ItemPosCountVec sDest;
3010 uint16 eDest = 0;
3011 if (IsInventoryPos(dst))
3012 msg = CanStoreItem(dstbag, dstslot, sDest, pSrcItem, true);
3013 else if (IsBankPos(dst))
3014 msg = CanBankItem(dstbag, dstslot, sDest, pSrcItem, true);
3015 else if (IsEquipmentPos(dst))
3016 {
3017 msg = CanEquipItem(dstslot, eDest, pSrcItem, true);
3018 if (msg == EQUIP_ERR_OK)
3019 msg = CanUnequipItem(eDest, true);
3020 }
3021
3022 if (msg != EQUIP_ERR_OK)
3023 {
3024 SendEquipError(msg, pSrcItem, pDstItem);
3025 return;
3026 }
3027
3028 // check dest->src move possibility
3029 ItemPosCountVec sDest2;
3030 uint16 eDest2 = 0;
3031 if (IsInventoryPos(src))
3032 msg = CanStoreItem(srcbag, srcslot, sDest2, pDstItem, true);
3033 else if (IsBankPos(src))
3034 msg = CanBankItem(srcbag, srcslot, sDest2, pDstItem, true);
3035 else if (IsEquipmentPos(src))
3036 {
3037 msg = CanEquipItem(srcslot, eDest2, pDstItem, true);
3038 if (msg == EQUIP_ERR_OK)
3039 msg = CanUnequipItem(eDest2, true);
3040 }
3041
3042 if (msg != EQUIP_ERR_OK)
3043 {
3044 SendEquipError(msg, pDstItem, pSrcItem);
3045 return;
3046 }
3047
3048 // Check bag swap with item exchange (one from empty in not bag possition (equipped (not possible in fact) or store)
3049 if (Bag* srcBag = pSrcItem->ToBag())
3050 {
3051 if (Bag* dstBag = pDstItem->ToBag())
3052 {
3053 Bag* emptyBag = NULL;
3054 Bag* fullBag = NULL;
3055 if (srcBag->IsEmpty() && !IsBagPos(src))
3056 {
3057 emptyBag = srcBag;
3058 fullBag = dstBag;
3059 }
3060 else if (dstBag->IsEmpty() && !IsBagPos(dst))
3061 {
3062 emptyBag = dstBag;
3063 fullBag = srcBag;
3064 }
3065
3066 // bag swap (with items exchange) case
3067 if (emptyBag && fullBag)
3068 {
3069 ItemTemplate const* emptyProto = emptyBag->GetTemplate();
3070
3071 uint32 count = 0;
3072
3073 for (uint32 i = 0; i < fullBag->GetBagSize(); ++i)
3074 {
3075 Item* bagItem = fullBag->GetItemByPos(i);
3076 if (!bagItem)
3077 continue;
3078
3079 ItemTemplate const* bagItemProto = bagItem->GetTemplate();
3080 if (!bagItemProto || !ItemCanGoIntoBag(bagItemProto, emptyProto))
3081 {
3082 // one from items not go to empty target bag
3083 SendEquipError(EQUIP_ERR_BAG_IN_BAG, pSrcItem, pDstItem);
3084 return;
3085 }
3086
3087 ++count;
3088 }
3089
3090 if (count > emptyBag->GetBagSize())
3091 {
3092 // too small targeted bag
3093 SendEquipError(EQUIP_ERR_CANT_SWAP, pSrcItem, pDstItem);
3094 return;
3095 }
3096
3097 // Items swap
3098 count = 0; // will pos in new bag
3099 for (uint32 i = 0; i < fullBag->GetBagSize(); ++i)
3100 {
3101 Item* bagItem = fullBag->GetItemByPos(i);
3102 if (!bagItem)
3103 continue;
3104
3105 fullBag->RemoveItem(i, true);
3106 emptyBag->StoreItem(count, bagItem, true);
3107 bagItem->SetState(ITEM_CHANGED, this);
3108
3109 ++count;
3110 }
3111 }
3112 }
3113 }
3114
3115 // now do moves, remove...
3116 RemoveItem(dstbag, dstslot, false);
3117 RemoveItem(srcbag, srcslot, false);
3118
3119 // add to dest
3120 if (IsInventoryPos(dst))
3121 StoreItem(sDest, pSrcItem, true);
3122 else if (IsBankPos(dst))
3123 BankItem(sDest, pSrcItem, true);
3124 else if (IsEquipmentPos(dst))
3125 EquipItem(eDest, pSrcItem, true);
3126
3127 // add to src
3128 if (IsInventoryPos(src))
3129 StoreItem(sDest2, pDstItem, true);
3130 else if (IsBankPos(src))
3131 BankItem(sDest2, pDstItem, true);
3132 else if (IsEquipmentPos(src))
3133 EquipItem(eDest2, pDstItem, true);
3134
3135 // if player is moving bags and is looting an item inside this bag
3136 // release the loot
3137 if (GetLootGUID())
3138 {
3139 bool released = false;
3140 if (IsBagPos(src))
3141 {
3142 Bag* bag = pSrcItem->ToBag();
3143 for (uint32 i = 0; i < bag->GetBagSize(); ++i)
3144 {
3145 if (Item* bagItem = bag->GetItemByPos(i))
3146 {
3147 if (bagItem->m_lootGenerated)
3148 {
3149 m_session->DoLootRelease(GetLootGUID());
3150 released = true; // so we don't need to look at dstBag
3151 break;
3152 }
3153 }
3154 }
3155 }
3156
3157 if (!released && IsBagPos(dst) && pDstItem)
3158 {
3159 Bag* bag = pDstItem->ToBag();
3160 for (uint32 i = 0; i < bag->GetBagSize(); ++i)
3161 {
3162 if (Item* bagItem = bag->GetItemByPos(i))
3163 {
3164 if (bagItem->m_lootGenerated)
3165 {
3166 m_session->DoLootRelease(GetLootGUID());
3167 released = true; // not realy needed here
3168 break;
3169 }
3170 }
3171 }
3172 }
3173 }
3174
3175 AutoUnequipOffhandIfNeed();
3176}
3177
3178void Player::AddItemToBuyBackSlot(Item* pItem)
3179{
3180 if (pItem)
3181 {
3182 uint32 slot = m_currentBuybackSlot;
3183 // if current back slot non-empty search oldest or free
3184 if (m_items[slot])
3185 {
3186 uint32 oldest_time = GetUInt32Value(PLAYER_FIELD_BUYBACK_TIMESTAMP);
3187 uint32 oldest_slot = BUYBACK_SLOT_START;
3188
3189 for (uint32 i = BUYBACK_SLOT_START + 1; i < BUYBACK_SLOT_END; ++i)
3190 {
3191 // found empty
3192 if (!m_items[i])
3193 {
3194 slot = i;
3195 break;
3196 }
3197
3198 uint32 i_time = GetUInt32Value(PLAYER_FIELD_BUYBACK_TIMESTAMP + i - BUYBACK_SLOT_START);
3199
3200 if (oldest_time > i_time)
3201 {
3202 oldest_time = i_time;
3203 oldest_slot = i;
3204 }
3205 }
3206
3207 // find oldest
3208 slot = oldest_slot;
3209 }
3210
3211 RemoveItemFromBuyBackSlot(slot, true);
3212 SF_LOG_DEBUG("entities.player.items", "STORAGE: AddItemToBuyBackSlot item = %u, slot = %u", pItem->GetEntry(), slot);
3213
3214 m_items[slot] = pItem;
3215 time_t base = time(NULL);
3216 uint32 etime = uint32(base - m_logintime + (30 * 3600));
3217 uint32 eslot = slot - BUYBACK_SLOT_START;
3218
3219 SetUInt64Value(PLAYER_FIELD_VENDORBUYBACK_SLOTS + (eslot * 2), pItem->GetGUID());
3220 if (ItemTemplate const* proto = pItem->GetTemplate())
3221 SetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE + eslot, proto->SellPrice * pItem->GetCount());
3222 else
3223 SetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE + eslot, 0);
3224 SetUInt32Value(PLAYER_FIELD_BUYBACK_TIMESTAMP + eslot, (uint32)etime);
3225
3226 // move to next (for non filled list is move most optimized choice)
3227 if (m_currentBuybackSlot < BUYBACK_SLOT_END - 1)
3228 ++m_currentBuybackSlot;
3229 }
3230}
3231
3232Item* Player::GetItemFromBuyBackSlot(uint32 slot)
3233{
3234 SF_LOG_DEBUG("entities.player.items", "STORAGE: GetItemFromBuyBackSlot slot = %u", slot);
3235 if (slot >= BUYBACK_SLOT_START && slot < BUYBACK_SLOT_END)
3236 return m_items[slot];
3237 return NULL;
3238}
3239
3240void Player::RemoveItemFromBuyBackSlot(uint32 slot, bool del)
3241{
3242 SF_LOG_DEBUG("entities.player.items", "STORAGE: RemoveItemFromBuyBackSlot slot = %u", slot);
3243 if (slot >= BUYBACK_SLOT_START && slot < BUYBACK_SLOT_END)
3244 {
3245 Item* pItem = m_items[slot];
3246 if (pItem)
3247 {
3248 pItem->RemoveFromWorld();
3249 if (del)
3250 pItem->SetState(ITEM_REMOVED, this);
3251 }
3252
3253 m_items[slot] = NULL;
3254
3255 uint32 eslot = slot - BUYBACK_SLOT_START;
3256 SetUInt64Value(PLAYER_FIELD_VENDORBUYBACK_SLOTS + (eslot * 2), 0);
3257 SetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE + eslot, 0);
3258 SetUInt32Value(PLAYER_FIELD_BUYBACK_TIMESTAMP + eslot, 0);
3259
3260 // if current backslot is filled set to now free slot
3261 if (m_items[m_currentBuybackSlot])
3262 m_currentBuybackSlot = slot;
3263 }
3264}
3265
3266void Player::SendEquipError(InventoryResult msg, Item* pItem, Item* pItem2, uint32 itemid)
3267{
3268 SF_LOG_DEBUG("network", "WORLD: Sent SMSG_INVENTORY_CHANGE_FAILURE (%u)", msg);
3269
3270 ObjectGuid pItemGuid = pItem ? pItem->GetGUID() : 0;
3271 ObjectGuid pItemGuid2 = pItem2 ? pItem2->GetGUID() : 0;
3272
3273 WorldPacket data(SMSG_INVENTORY_CHANGE_FAILURE, (msg == EQUIP_ERR_CANT_EQUIP_LEVEL_I ? 22 : 18));
3274
3275 if (msg != EQUIP_ERR_OK)
3276 {
3277 data.WriteGuidMask(pItemGuid2, 4);
3278 data.WriteGuidMask(pItemGuid, 3);
3279 data.WriteGuidMask(pItemGuid2, 6, 2);
3280 data.WriteGuidMask(pItemGuid, 4);
3281 data.WriteGuidMask(pItemGuid2, 5);
3282 data.WriteGuidMask(pItemGuid, 1, 6);
3283 data.WriteGuidMask(pItemGuid2, 0, 3, 1);
3284 data.WriteGuidMask(pItemGuid, 2, 0, 5, 7);
3285 data.WriteGuidMask(pItemGuid2, 7);
3286
3287 data.WriteGuidBytes(pItemGuid2, 0);
3288 data << uint8(0); // bag type subclass, used with EQUIP_ERR_EVENT_AUTOEQUIP_BIND_CONFIRM and EQUIP_ERR_ITEM_DOESNT_GO_INTO_BAG2
3289 data.WriteGuidBytes(pItemGuid2, 6);
3290 data.WriteGuidBytes(pItemGuid, 4, 0, 7, 3);
3291 data.WriteGuidBytes(pItemGuid2, 1, 5);
3292 data.WriteGuidBytes(pItemGuid, 5);
3293 data.WriteGuidBytes(pItemGuid2, 7, 2);
3294 data.WriteGuidBytes(pItemGuid, 1, 6, 2);
3295 data.WriteGuidBytes(pItemGuid2, 3, 4);
3296 data << uint8(msg);
3297
3298 if (msg == EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_COUNT_EXCEEDED_IS
3299 || msg == EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_SOCKETED_EXCEEDED_IS
3300 || msg == EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_EQUIPPED_EXCEEDED_IS)
3301 {
3302 ItemTemplate const* proto = pItem ? pItem->GetTemplate() : sObjectMgr->GetItemTemplate(itemid);
3303 data << uint32(proto ? proto->ItemLimitCategory : 0);
3304 }
3305
3306 if (msg == EQUIP_ERR_NO_OUTPUT) // no idea about this one...
3307 data << uint32(0); // slot
3308
3309 if (msg == EQUIP_ERR_CANT_EQUIP_LEVEL_I || msg == EQUIP_ERR_PURCHASE_LEVEL_TOO_LOW)
3310 {
3311 ItemTemplate const* proto = pItem ? pItem->GetTemplate() : sObjectMgr->GetItemTemplate(itemid);
3312 data << uint32(proto ? proto->RequiredLevel : 0);
3313 }
3314
3315 if (msg == EQUIP_ERR_NO_OUTPUT)
3316 {
3317 data.WriteBits(0, 8); // container
3318 data.WriteBits(0, 8); // item guid
3319 }
3320 }
3321
3322 GetSession()->SendPacket(&data);
3323}
3324
3325void Player::SendGameError(GameError error, uint32 arg1, uint32 arg2)
3326{
3327 SF_LOG_DEBUG("network", "WORLD: Sent SMSG_DISPLAY_GAME_ERROR (%u)", uint32(error));
3328
3329 WorldPacket data(SMSG_DISPLAY_GAME_ERROR);
3330 data << uint32(error);
3331 data.WriteBit(arg1 != 0);
3332 data.WriteBit(arg2 != 0);
3333
3334 if (arg1)
3335 data << uint32(arg1);
3336
3337 if (arg2)
3338 data << uint32(arg2);
3339
3340 GetSession()->SendPacket(&data);
3341}
3342
3343bool Player::IsUseEquipedWeapon(bool mainhand) const
3344{
3345 // disarm applied only to mainhand weapon
3346 return !IsInFeralForm() && (!mainhand || !HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISARMED));
3347}
3348
3349bool Player::IsTwoHandUsed() const
3350{
3351 Item* mainItem = GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
3352 return mainItem && mainItem->GetTemplate()->InventoryType == INVTYPE_2HWEAPON && !CanTitanGrip();
3353}
3354
3355InventoryResult Player::CanEquipUniqueItem(Item* pItem, uint8 eslot, uint32 limit_count) const
3356{
3357 ItemTemplate const* pProto = pItem->GetTemplate();
3358
3359 // proto based limitations
3360 if (InventoryResult res = CanEquipUniqueItem(pProto, eslot, limit_count))
3361 return res;
3362
3363 // check unique-equipped on gems
3364 for (uint32 enchant_slot = SOCK_ENCHANTMENT_SLOT; enchant_slot < SOCK_ENCHANTMENT_SLOT + 3; ++enchant_slot)
3365 {
3366 uint32 enchant_id = pItem->GetEnchantmentId(EnchantmentSlot(enchant_slot));
3367 if (!enchant_id)
3368 continue;
3369 SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
3370 if (!enchantEntry)
3371 continue;
3372
3373 ItemTemplate const* pGem = sObjectMgr->GetItemTemplate(enchantEntry->GemID);
3374 if (!pGem)
3375 continue;
3376
3377 // include for check equip another gems with same limit category for not equipped item (and then not counted)
3378 uint32 gem_limit_count = !pItem->IsEquipped() && pGem->ItemLimitCategory
3379 ? pItem->GetGemCountWithLimitCategory(pGem->ItemLimitCategory) : 1;
3380
3381 if (InventoryResult res = CanEquipUniqueItem(pGem, eslot, gem_limit_count))
3382 return res;
3383 }
3384
3385 return EQUIP_ERR_OK;
3386}
3387
3388InventoryResult Player::CanEquipUniqueItem(ItemTemplate const* itemProto, uint8 except_slot, uint32 limit_count) const
3389{
3390 // check unique-equipped on item
3391 if (itemProto->Flags & ITEM_PROTO_FLAG_UNIQUE_EQUIPPED)
3392 {
3393 // there is an equip limit on this item
3394 if (HasItemOrGemWithIdEquipped(itemProto->ItemId, 1, except_slot))
3395 return EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE;
3396 }
3397
3398 // check unique-equipped limit
3399 if (itemProto->ItemLimitCategory)
3400 {
3401 ItemLimitCategoryEntry const* limitEntry = sItemLimitCategoryStore.LookupEntry(itemProto->ItemLimitCategory);
3402 if (!limitEntry)
3403 return EQUIP_ERR_NOT_EQUIPPABLE;
3404
3405 // NOTE: limitEntry->mode not checked because if item have have-limit then it applied and to equip case
3406
3407 if (limit_count > limitEntry->maxCount)
3408 return EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_EQUIPPED_EXCEEDED_IS;
3409
3410 // there is an equip limit on this item
3411 if (HasItemOrGemWithLimitCategoryEquipped(itemProto->ItemLimitCategory, limitEntry->maxCount - limit_count + 1, except_slot))
3412 return EQUIP_ERR_ITEM_MAX_COUNT_EQUIPPED_SOCKETED;
3413 }
3414
3415 return EQUIP_ERR_OK;
3416}
MAX_BAG_SIZE
#define MAX_BAG_SIZE
Definition Bag.h:10
STATUS_IN_PROGRESS
@ STATUS_IN_PROGRESS
Definition Battleground.h:148
CHAR_DEL_GIFT
@ CHAR_DEL_GIFT
Definition CharacterDatabase.h:145
CHAR_INS_ITEM_BOP_TRADE
@ CHAR_INS_ITEM_BOP_TRADE
Definition CharacterDatabase.h:134
DEFAULT_MAX_LEVEL
@ DEFAULT_MAX_LEVEL
Definition DBCEnums.h:16
ITEM_LIMIT_CATEGORY_MODE_HAVE
@ ITEM_LIMIT_CATEGORY_MODE_HAVE
Definition DBCEnums.h:432
ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM
@ ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM
Definition DBCEnums.h:222
ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM
@ ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM
Definition DBCEnums.h:201
ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM
@ ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM
Definition DBCEnums.h:214
ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM
@ ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM
Definition DBCEnums.h:252
sSpellItemEnchantmentStore
DBCStorage< SpellItemEnchantmentEntry > sSpellItemEnchantmentStore(SpellItemEnchantmentfmt)
sScalingStatDistributionStore
DBCStorage< ScalingStatDistributionEntry > sScalingStatDistributionStore(ScalingStatDistributionfmt)
sItemLimitCategoryStore
DBCStorage< ItemLimitCategoryEntry > sItemLimitCategoryStore(ItemLimitCategoryEntryfmt)
int32
std::int32_t int32
Definition Define.h:73
uint8
std::uint8_t uint8
Definition Define.h:79
uint32
std::uint32_t uint32
Definition Define.h:77
uint64
std::uint64_t uint64
Definition Define.h:76
uint16
std::uint16_t uint16
Definition Define.h:78
IsHolidayActive
bool IsHolidayActive(HolidayIds id)
Definition GameEventMgr.cpp:1597
ItemCanGoIntoBag
bool ItemCanGoIntoBag(ItemTemplate const *pProto, ItemTemplate const *pBagProto)
Definition Item.cpp:160
EnchantmentSlot
EnchantmentSlot
Definition Item.h:149
PERM_ENCHANTMENT_SLOT
@ PERM_ENCHANTMENT_SLOT
Definition Item.h:150
PROP_ENCHANTMENT_SLOT_0
@ PROP_ENCHANTMENT_SLOT_0
Definition Item.h:160
TEMP_ENCHANTMENT_SLOT
@ TEMP_ENCHANTMENT_SLOT
Definition Item.h:151
PRISMATIC_ENCHANTMENT_SLOT
@ PRISMATIC_ENCHANTMENT_SLOT
Definition Item.h:156
PROP_ENCHANTMENT_SLOT_1
@ PROP_ENCHANTMENT_SLOT_1
Definition Item.h:161
SOCK_ENCHANTMENT_SLOT
@ SOCK_ENCHANTMENT_SLOT
Definition Item.h:152
PROP_ENCHANTMENT_SLOT_4
@ PROP_ENCHANTMENT_SLOT_4
Definition Item.h:164
PROP_ENCHANTMENT_SLOT_3
@ PROP_ENCHANTMENT_SLOT_3
Definition Item.h:163
InventoryResult
InventoryResult
Definition Item.h:27
EQUIP_ERR_CANT_EQUIP_EVER
@ EQUIP_ERR_CANT_EQUIP_EVER
Definition Item.h:38
EQUIP_ERR_NO_SLOT_AVAILABLE
@ EQUIP_ERR_NO_SLOT_AVAILABLE
Definition Item.h:37
EQUIP_ERR_ONLY_ONE_QUIVER
@ EQUIP_ERR_ONLY_ONE_QUIVER
Definition Item.h:61
EQUIP_ERR_ITEM_MAX_COUNT_EQUIPPED_SOCKETED
@ EQUIP_ERR_ITEM_MAX_COUNT_EQUIPPED_SOCKETED
Definition Item.h:103
EQUIP_ERR_DESTROY_NONEMPTY_BAG
@ EQUIP_ERR_DESTROY_NONEMPTY_BAG
Definition Item.h:59
EQUIP_ERR_SPLIT_FAILED
@ EQUIP_ERR_SPLIT_FAILED
Definition Item.h:55
EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE
@ EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE
Definition Item.h:95
EQUIP_ERR_NOT_DURING_ARENA_MATCH
@ EQUIP_ERR_NOT_DURING_ARENA_MATCH
Definition Item.h:106
EQUIP_ERR_NO_OUTPUT
@ EQUIP_ERR_NO_OUTPUT
Definition Item.h:109
EQUIP_ERR_PLAYER_DEAD
@ EQUIP_ERR_PLAYER_DEAD
Definition Item.h:66
EQUIP_ERR_BAG_IN_BAG
@ EQUIP_ERR_BAG_IN_BAG
Definition Item.h:33
EQUIP_ERR_CLIENT_LOCKED_OUT
@ EQUIP_ERR_CLIENT_LOCKED_OUT
Definition Item.h:67
EQUIP_ERR_BANK_FULL
@ EQUIP_ERR_BANK_FULL
Definition Item.h:79
EQUIP_ERR_NOT_IN_COMBAT
@ EQUIP_ERR_NOT_IN_COMBAT
Definition Item.h:88
EQUIP_ERR_CANT_EQUIP_LEVEL_I
@ EQUIP_ERR_CANT_EQUIP_LEVEL_I
Definition Item.h:29
EQUIP_ERR_GENERIC_STUNNED
@ EQUIP_ERR_GENERIC_STUNNED
Definition Item.h:65
EQUIP_ERR_WRONG_SLOT
@ EQUIP_ERR_WRONG_SLOT
Definition Item.h:31
EQUIP_ERR_WRONG_BAG_TYPE
@ EQUIP_ERR_WRONG_BAG_TYPE
Definition Item.h:43
EQUIP_ERR_PROFICIENCY_NEEDED
@ EQUIP_ERR_PROFICIENCY_NEEDED
Definition Item.h:36
EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_COUNT_EXCEEDED_IS
@ EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_COUNT_EXCEEDED_IS
Definition Item.h:111
EQUIP_ERR_NO_BANK_SLOT
@ EQUIP_ERR_NO_BANK_SLOT
Definition Item.h:62
EQUIP_ERR_PURCHASE_LEVEL_TOO_LOW
@ EQUIP_ERR_PURCHASE_LEVEL_TOO_LOW
Definition Item.h:114
EQUIP_ERR_ITEM_NOT_FOUND
@ EQUIP_ERR_ITEM_NOT_FOUND
Definition Item.h:51
EQUIP_ERR_CANT_EQUIP_REPUTATION
@ EQUIP_ERR_CANT_EQUIP_REPUTATION
Definition Item.h:92
EQUIP_ERR_OK
@ EQUIP_ERR_OK
Definition Item.h:28
EQUIP_ERR_LOOT_GONE
@ EQUIP_ERR_LOOT_GONE
Definition Item.h:77
EQUIP_ERR_CANT_SWAP
@ EQUIP_ERR_CANT_SWAP
Definition Item.h:49
EQUIP_ERR_NOT_OWNER
@ EQUIP_ERR_NOT_OWNER
Definition Item.h:60
EQUIP_ERR_CANT_EQUIP_SKILL
@ EQUIP_ERR_CANT_EQUIP_SKILL
Definition Item.h:30
EQUIP_ERR_2HANDED_EQUIPPED
@ EQUIP_ERR_2HANDED_EQUIPPED
Definition Item.h:41
EQUIP_ERR_INV_FULL
@ EQUIP_ERR_INV_FULL
Definition Item.h:78
EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_EQUIPPED_EXCEEDED_IS
@ EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_EQUIPPED_EXCEEDED_IS
Definition Item.h:116
EQUIP_ERR_NOT_EQUIPPABLE
@ EQUIP_ERR_NOT_EQUIPPABLE
Definition Item.h:48
EQUIP_ERR_2HSKILLNOTFOUND
@ EQUIP_ERR_2HSKILLNOTFOUND
Definition Item.h:42
EQUIP_ERR_ONLY_ONE_AMMO
@ EQUIP_ERR_ONLY_ONE_AMMO
Definition Item.h:70
EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_SOCKETED_EXCEEDED_IS
@ EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_SOCKETED_EXCEEDED_IS
Definition Item.h:112
EQUIP_ERR_ITEM_MAX_COUNT
@ EQUIP_ERR_ITEM_MAX_COUNT
Definition Item.h:45
EQUIP_ERR_TOO_FEW_TO_SPLIT
@ EQUIP_ERR_TOO_FEW_TO_SPLIT
Definition Item.h:54
ITEM_CHANGED
@ ITEM_CHANGED
Definition Item.h:192
ITEM_REMOVED
@ ITEM_REMOVED
Definition Item.h:194
ITEM_NEW
@ ITEM_NEW
Definition Item.h:193
ITEM_SUBCLASS_WEAPON_POLEARM
@ ITEM_SUBCLASS_WEAPON_POLEARM
Definition ItemPrototype.h:351
INVTYPE_CLOAK
@ INVTYPE_CLOAK
Definition ItemPrototype.h:270
INVTYPE_RELIC
@ INVTYPE_RELIC
Definition ItemPrototype.h:282
INVTYPE_WEAPON
@ INVTYPE_WEAPON
Definition ItemPrototype.h:267
INVTYPE_WEAPONOFFHAND
@ INVTYPE_WEAPONOFFHAND
Definition ItemPrototype.h:276
INVTYPE_2HWEAPON
@ INVTYPE_2HWEAPON
Definition ItemPrototype.h:271
ITEM_SPELLTRIGGER_ON_NO_DELAY_USE
@ ITEM_SPELLTRIGGER_ON_NO_DELAY_USE
Definition ItemPrototype.h:81
ITEM_SUBCLASS_CONTAINER
@ ITEM_SUBCLASS_CONTAINER
Definition ItemPrototype.h:328
ITEM_SUBCLASS_AMMO_POUCH
@ ITEM_SUBCLASS_AMMO_POUCH
Definition ItemPrototype.h:486
ITEM_PROTO_FLAG_UNIQUE_EQUIPPED
@ ITEM_PROTO_FLAG_UNIQUE_EQUIPPED
Definition ItemPrototype.h:123
ITEM_PROTO_FLAG_OPENABLE
@ ITEM_PROTO_FLAG_OPENABLE
Definition ItemPrototype.h:106
ITEM_SUBCLASS_ARMOR_MAIL
@ ITEM_SUBCLASS_ARMOR_MAIL
Definition ItemPrototype.h:396
ITEM_SUBCLASS_ARMOR_BUCKLER
@ ITEM_SUBCLASS_ARMOR_BUCKLER
Definition ItemPrototype.h:398
ITEM_SUBCLASS_ARMOR_CLOTH
@ ITEM_SUBCLASS_ARMOR_CLOTH
Definition ItemPrototype.h:394
ITEM_SUBCLASS_ARMOR_LEATHER
@ ITEM_SUBCLASS_ARMOR_LEATHER
Definition ItemPrototype.h:395
ITEM_SUBCLASS_ARMOR_PLATE
@ ITEM_SUBCLASS_ARMOR_PLATE
Definition ItemPrototype.h:397
ITEM_SUBCLASS_ARMOR_MISCELLANEOUS
@ ITEM_SUBCLASS_ARMOR_MISCELLANEOUS
Definition ItemPrototype.h:393
ITEM_SUBCLASS_LEATHER
@ ITEM_SUBCLASS_LEATHER
Definition ItemPrototype.h:435
ITEM_FLAGS_EXTRA_ALLIANCE_ONLY
@ ITEM_FLAGS_EXTRA_ALLIANCE_ONLY
Definition ItemPrototype.h:179
ITEM_FLAGS_EXTRA_HORDE_ONLY
@ ITEM_FLAGS_EXTRA_HORDE_ONLY
Definition ItemPrototype.h:178
MAX_ITEM_PROTO_SPELLS
#define MAX_ITEM_PROTO_SPELLS
Definition ItemPrototype.h:624
BIND_WHEN_EQUIPED
@ BIND_WHEN_EQUIPED
Definition ItemPrototype.h:91
BIND_QUEST_ITEM
@ BIND_QUEST_ITEM
Definition ItemPrototype.h:93
BIND_WHEN_PICKED_UP
@ BIND_WHEN_PICKED_UP
Definition ItemPrototype.h:90
ITEM_CLASS_QUIVER
@ ITEM_CLASS_QUIVER
Definition ItemPrototype.h:300
ITEM_CLASS_CONTAINER
@ ITEM_CLASS_CONTAINER
Definition ItemPrototype.h:290
ITEM_CLASS_ARMOR
@ ITEM_CLASS_ARMOR
Definition ItemPrototype.h:293
ITEM_CLASS_WEAPON
@ ITEM_CLASS_WEAPON
Definition ItemPrototype.h:291
ITEM_FLAG_BOP_TRADEABLE
@ ITEM_FLAG_BOP_TRADEABLE
Definition ItemPrototype.h:148
ITEM_FLAG_WRAPPED
@ ITEM_FLAG_WRAPPED
Definition ItemPrototype.h:143
MAX_ITEM_SUBCLASS_WEAPON
#define MAX_ITEM_SUBCLASS_WEAPON
Definition ItemPrototype.h:372
sLFGMgr
#define sLFGMgr
Definition LFGMgr.h:518
SF_LOG_DEBUG
#define SF_LOG_DEBUG(filterType__,...)
Definition Log.h:134
SF_LOG_ERROR
#define SF_LOG_ERROR(filterType__,...)
Definition Log.h:143
AllowedLooterSet
std::set< uint32 > AllowedLooterSet
Definition LootMgr.h:116
sObjectMgr
#define sObjectMgr
Definition ObjectMgr.h:1617
AddItemsSetItem
void AddItemsSetItem(Player *player, Item *item)
Definition Item.cpp:20
ItemPosCountVec
std::vector< ItemPosCount > ItemPosCountVec
Definition Player.h:777
INVENTORY_SLOT_ITEM_START
@ INVENTORY_SLOT_ITEM_START
Definition Player.h:719
INVENTORY_SLOT_ITEM_END
@ INVENTORY_SLOT_ITEM_END
Definition Player.h:720
RemoveItemsSetItem
void RemoveItemsSetItem(Player *player, ItemTemplate const *proto)
Definition Item.cpp:102
BUYBACK_SLOT_END
@ BUYBACK_SLOT_END
Definition Player.h:739
BUYBACK_SLOT_START
@ BUYBACK_SLOT_START
Definition Player.h:738
INVENTORY_SLOT_BAG_START
@ INVENTORY_SLOT_BAG_START
Definition Player.h:713
INVENTORY_SLOT_BAG_END
@ INVENTORY_SLOT_BAG_END
Definition Player.h:714
BANK_SLOT_BAG_END
@ BANK_SLOT_BAG_END
Definition Player.h:732
BANK_SLOT_BAG_START
@ BANK_SLOT_BAG_START
Definition Player.h:731
BANK_SLOT_ITEM_START
@ BANK_SLOT_ITEM_START
Definition Player.h:725
BANK_SLOT_ITEM_END
@ BANK_SLOT_ITEM_END
Definition Player.h:726
EQUIPMENT_SLOT_FINGER1
@ EQUIPMENT_SLOT_FINGER1
Definition Player.h:699
EQUIPMENT_SLOT_FINGER2
@ EQUIPMENT_SLOT_FINGER2
Definition Player.h:700
EQUIPMENT_SLOT_MAINHAND
@ EQUIPMENT_SLOT_MAINHAND
Definition Player.h:704
EQUIPMENT_SLOT_TRINKET1
@ EQUIPMENT_SLOT_TRINKET1
Definition Player.h:701
EQUIPMENT_SLOT_END
@ EQUIPMENT_SLOT_END
Definition Player.h:708
EQUIPMENT_SLOT_OFFHAND
@ EQUIPMENT_SLOT_OFFHAND
Definition Player.h:705
EQUIPMENT_SLOT_TRINKET2
@ EQUIPMENT_SLOT_TRINKET2
Definition Player.h:702
EQUIPMENT_SLOT_START
@ EQUIPMENT_SLOT_START
Definition Player.h:688
INVENTORY_SLOT_BAG_0
#define INVENTORY_SLOT_BAG_0
Definition Player.h:684
TRADE_SLOT_INVALID
@ TRADE_SLOT_INVALID
Definition Player.h:784
PLAYER_SLOT_END
@ PLAYER_SLOT_END
Definition Player.h:680
GameError
GameError
Definition SharedDefines.h:4282
ITEM_QUALITY_HEIRLOOM
@ ITEM_QUALITY_HEIRLOOM
Definition SharedDefines.h:309
CLASS_HUNTER
@ CLASS_HUNTER
Definition SharedDefines.h:142
CLASS_DRUID
@ CLASS_DRUID
Definition SharedDefines.h:150
CLASS_SHAMAN
@ CLASS_SHAMAN
Definition SharedDefines.h:146
CLASS_MONK
@ CLASS_MONK
Definition SharedDefines.h:149
CLASS_PRIEST
@ CLASS_PRIEST
Definition SharedDefines.h:144
CLASS_WARRIOR
@ CLASS_WARRIOR
Definition SharedDefines.h:140
CLASS_WARLOCK
@ CLASS_WARLOCK
Definition SharedDefines.h:148
CLASS_MAGE
@ CLASS_MAGE
Definition SharedDefines.h:147
CLASS_DEATH_KNIGHT
@ CLASS_DEATH_KNIGHT
Definition SharedDefines.h:145
CLASS_PALADIN
@ CLASS_PALADIN
Definition SharedDefines.h:141
CLASS_ROGUE
@ CLASS_ROGUE
Definition SharedDefines.h:143
ALLIANCE
@ ALLIANCE
Definition SharedDefines.h:877
HORDE
@ HORDE
Definition SharedDefines.h:876
HolidayIds
HolidayIds
Definition SharedDefines.h:3227
SKILL_BOWS
@ SKILL_BOWS
Definition SharedDefines.h:3372
SKILL_MACES
@ SKILL_MACES
Definition SharedDefines.h:3374
SKILL_PLATE_MAIL
@ SKILL_PLATE_MAIL
Definition SharedDefines.h:3437
SKILL_WANDS
@ SKILL_WANDS
Definition SharedDefines.h:3432
SKILL_GUNS
@ SKILL_GUNS
Definition SharedDefines.h:3373
SKILL_CROSSBOWS
@ SKILL_CROSSBOWS
Definition SharedDefines.h:3431
SKILL_FISHING
@ SKILL_FISHING
Definition SharedDefines.h:3441
SKILL_SWORDS
@ SKILL_SWORDS
Definition SharedDefines.h:3370
SKILL_DAGGERS
@ SKILL_DAGGERS
Definition SharedDefines.h:3406
SKILL_2H_AXES
@ SKILL_2H_AXES
Definition SharedDefines.h:3405
SKILL_POLEARMS
@ SKILL_POLEARMS
Definition SharedDefines.h:3433
SKILL_2H_SWORDS
@ SKILL_2H_SWORDS
Definition SharedDefines.h:3375
SKILL_MAIL
@ SKILL_MAIL
Definition SharedDefines.h:3443
SKILL_FIST_WEAPONS
@ SKILL_FIST_WEAPONS
Definition SharedDefines.h:3447
SKILL_2H_MACES
@ SKILL_2H_MACES
Definition SharedDefines.h:3400
SKILL_AXES
@ SKILL_AXES
Definition SharedDefines.h:3371
SKILL_STAVES
@ SKILL_STAVES
Definition SharedDefines.h:3388
sSpellMgr
#define sSpellMgr
Definition SpellMgr.h:744
WeaponAttackType
WeaponAttackType
Definition Unit.h:572
CombatRating::CR_ARMOR_PENETRATION
@ CR_ARMOR_PENETRATION
Definition Unit.h:605
NULL_BAG
@ NULL_BAG
Definition Unit.h:336
NULL_SLOT
@ NULL_SLOT
Definition Unit.h:337
UNIT_STATE_STUNNED
@ UNIT_STATE_STUNNED
Definition Unit.h:515
UNIT_FLAG_DISARMED
@ UNIT_FLAG_DISARMED
Definition Unit.h:646
UNIT_FIELD_FLAGS
@ UNIT_FIELD_FLAGS
Definition UpdateFields.h:82
ITEM_FIELD_CONTAINED_IN
@ ITEM_FIELD_CONTAINED_IN
Definition UpdateFields.h:25
ITEM_FIELD_OWNER
@ ITEM_FIELD_OWNER
Definition UpdateFields.h:24
ITEM_FIELD_DYNAMIC_FLAGS
@ ITEM_FIELD_DYNAMIC_FLAGS
Definition UpdateFields.h:31
ITEM_FIELD_CREATE_PLAYED_TIME
@ ITEM_FIELD_CREATE_PLAYED_TIME
Definition UpdateFields.h:37
PLAYER_FIELD_VENDORBUYBACK_SLOTS
@ PLAYER_FIELD_VENDORBUYBACK_SLOTS
Definition UpdateFields.h:164
PLAYER_FIELD_BUYBACK_TIMESTAMP
@ PLAYER_FIELD_BUYBACK_TIMESTAMP
Definition UpdateFields.h:218
PLAYER_FIELD_BUYBACK_PRICE
@ PLAYER_FIELD_BUYBACK_PRICE
Definition UpdateFields.h:217
PLAYER_FIELD_VISIBLE_ITEMS
@ PLAYER_FIELD_VISIBLE_ITEMS
Definition UpdateFields.h:153
PLAYER_FIELD_INV_SLOTS
@ PLAYER_FIELD_INV_SLOTS
Definition UpdateFields.h:160
Bag
Definition Bag.h:16
Bag::GetBagSize
uint32 GetBagSize() const
Definition Bag.h:36
Bag::StoreItem
void StoreItem(uint8 slot, Item *pItem, bool update)
Definition Bag.cpp:144
Bag::IsEmpty
bool IsEmpty() const
Definition Bag.cpp:169
Bag::GetItemByPos
Item * GetItemByPos(uint8 slot) const
Definition Bag.cpp:225
Bag::RemoveItem
void RemoveItem(uint8 slot, bool update)
Definition Bag.cpp:133
ByteBuffer::WriteGuidBytes
void WriteGuidBytes(const ObjectGuid &guid, Offsets... offsets)
Definition ByteBuffer.h:264
ByteBuffer::WriteBit
bool WriteBit(uint32 bit)
Definition ByteBuffer.h:164
ByteBuffer::WriteGuidMask
void WriteGuidMask(const ObjectGuid &guid, Offsets... offsets)
Definition ByteBuffer.h:248
ByteBuffer::bitwpos
size_t bitwpos() const
Returns position of last written bit.
Definition ByteBuffer.h:492
ByteBuffer::WriteBits
void WriteBits(T value, size_t bits)
Definition ByteBuffer.h:192
ByteBuffer::WriteByteSeq
void WriteByteSeq(uint8 b)
Definition ByteBuffer.h:227
GlobalCooldownMgr::AddGlobalCooldown
void AddGlobalCooldown(SpellInfo const *spellInfo, uint32 gcd)
Definition Unit.cpp:254
Item
Definition Item.h:202
Item::GetSlot
uint8 GetSlot() const
Definition Item.h:265
Item::IsCurrencyToken
bool IsCurrencyToken() const
Definition Item.h:245
Item::SetNotRefundable
void SetNotRefundable(Player *owner, bool changestate=true, SQLTransaction *trans=NULL)
Definition Item.cpp:1111
Item::SetBinding
void SetBinding(bool val)
Definition Item.h:217
Item::SetState
void SetState(ItemUpdateState state, Player *forplayer=NULL)
Definition Item.cpp:667
Item::GetEnchantmentId
uint32 GetEnchantmentId(EnchantmentSlot slot) const
Definition Item.h:287
Item::SetOwnerGUID
void SetOwnerGUID(uint64 guid)
Definition Item.h:214
Item::SetSoulboundTradeable
void SetSoulboundTradeable(AllowedLooterSet const &allowedLooters)
Definition Item.cpp:1169
Item::SetItemRandomProperties
void SetItemRandomProperties(int32 randomPropId)
Definition Item.cpp:621
Item::GetGemCountWithID
uint8 GetGemCountWithID(uint32 GemID) const
Definition Item.cpp:944
Item::ToBag
Bag * ToBag()
Definition Item.h:240
Item::CloneItem
Item * CloneItem(uint32 count, Player const *player=NULL) const
Definition Item.cpp:1039
Item::ItemContainerDeleteLootMoneyAndLootItemsFromDB
void ItemContainerDeleteLootMoneyAndLootItemsFromDB()
Definition Item.cpp:1673
Item::SetCount
void SetCount(uint32 value)
Definition Item.h:259
Item::GetTemplate
ItemTemplate const * GetTemplate() const
Definition Item.cpp:528
Item::GetVisibleEntry
uint32 GetVisibleEntry() const
Definition Item.h:353
Item::IsSoulBound
bool IsSoulBound() const
Definition Item.h:218
Item::IsBroken
bool IsBroken() const
Definition Item.h:247
Item::GetItemSuffixFactor
uint32 GetItemSuffixFactor() const
Definition Item.h:279
Item::IsBindedNotWith
bool IsBindedNotWith(Player const *player) const
Definition Item.cpp:1055
Item::IsEquipped
bool IsEquipped() const
Definition Item.cpp:739
Item::GetSkill
uint32 GetSkill()
Definition Item.cpp:538
Item::CreateItem
static Item * CreateItem(uint32 itemEntry, uint32 count, Player const *player=NULL)
Definition Item.cpp:1012
Item::IsInTrade
bool IsInTrade() const
Definition Item.h:250
Item::IsBag
bool IsBag() const
Definition Item.h:244
Item::ClearEnchantment
void ClearEnchantment(EnchantmentSlot slot)
Definition Item.cpp:897
Item::CanBeMergedPartlyWith
InventoryResult CanBeMergedPartlyWith(ItemTemplate const *proto) const
Definition Item.cpp:803
Item::GetOwnerGUID
uint64 GetOwnerGUID() const
Definition Item.h:213
Item::GetGemCountWithLimitCategory
uint8 GetGemCountWithLimitCategory(uint32 limitCategory) const
Definition Item.cpp:963
Item::ClearSoulboundTradeable
void ClearSoulboundTradeable(Player *currentOwner)
Definition Item.cpp:1175
Item::SetSlot
void SetSlot(uint8 slot)
Definition Item.h:268
Item::IsNotEmptyBag
bool IsNotEmptyBag() const
Definition Item.cpp:280
Item::m_lootGenerated
bool m_lootGenerated
Definition Item.h:302
Item::GetCount
uint32 GetCount() const
Definition Item.h:258
Item::SetContainer
void SetContainer(Bag *container)
Definition Item.h:270
Item::GetBagSlot
uint8 GetBagSlot() const
Definition Item.cpp:734
Item::GenerateItemRandomPropertyId
static int32 GenerateItemRandomPropertyId(uint32 item_id)
Definition Item.cpp:575
Map
Definition Map.h:238
Map::GetDifficulty
DifficultyID GetDifficulty() const
Definition Map.h:363
Map::GetId
uint32 GetId(void) const
Definition Map.h:300
Object::GetGUID
uint64 GetGUID() const
Definition Object.h:119
Object::SetUInt16Value
void SetUInt16Value(uint16 index, uint8 offset, uint16 value)
Definition Object.cpp:1182
Object::GetUInt32Value
uint32 GetUInt32Value(uint16 index) const
Definition Object.cpp:325
Object::IsInWorld
bool IsInWorld() const
Definition Object.h:114
Object::DestroyForPlayer
virtual void DestroyForPlayer(Player *target, bool onDeath=false) const
Definition Object.cpp:287
Object::GetGUIDLow
uint32 GetGUIDLow() const
Definition Object.h:120
Object::GetEntry
uint32 GetEntry() const
Definition Object.h:125
Object::AddToWorld
virtual void AddToWorld()
Definition Object.cpp:148
Object::HasFlag
bool HasFlag(uint16 index, uint32 flag) const
Definition Object.cpp:1309
Object::RemoveFromWorld
virtual void RemoveFromWorld()
Definition Object.cpp:161
Object::SendUpdateToPlayer
void SendUpdateToPlayer(Player *player)
Definition Object.cpp:259
Object::SetUInt32Value
void SetUInt32Value(uint16 index, uint32 value)
Definition Object.cpp:1038
Object::SetUInt64Value
void SetUInt64Value(uint16 index, uint64 value)
Definition Object.cpp:1079
Player::StoreNewItemInBestSlots
bool StoreNewItemInBestSlots(uint32 item_id, uint32 item_count)
Definition PlayerStorage.cpp:1170
Player::SendEquipError
void SendEquipError(InventoryResult msg, Item *pItem, Item *pItem2=NULL, uint32 itemid=0)
Definition PlayerStorage.cpp:3266
Player::ItemRemovedQuestCheck
void ItemRemovedQuestCheck(uint32 entry, uint32 count)
Definition PlayerQuestState.cpp:1659
Player::IsEquipmentPos
static bool IsEquipmentPos(uint16 pos)
Definition Player.h:1536
Player::GetTeam
uint32 GetTeam() const
Definition Player.h:2527
Player::CanUnequipItem
InventoryResult CanUnequipItem(uint16 src, bool swap) const
Definition PlayerStorage.cpp:1427
Player::RemoveItemDependentAurasAndCasts
void RemoveItemDependentAurasAndCasts(Item *pItem)
Definition Player.cpp:19622
Player::CanEquipItem
InventoryResult CanEquipItem(uint8 slot, uint16 &dest, Item *pItem, bool swap, bool not_loading=true) const
Definition PlayerStorage.cpp:1265
Player::CanEquipNewItem
InventoryResult CanEquipNewItem(uint8 slot, uint16 &dest, uint32 item, bool swap) const
Definition PlayerStorage.cpp:1251
Player::GetBagByPos
Bag * GetBagByPos(uint8 slot) const
Definition PlayerStorage.cpp:148
Player::QuickEquipItem
void QuickEquipItem(uint16 pos, Item *pItem)
Definition PlayerStorage.cpp:2152
Player::GetTotalPlayedTime
uint32 GetTotalPlayedTime() const
Definition Player.h:1424
Player::CanRollForItemInLFG
InventoryResult CanRollForItemInLFG(ItemTemplate const *item, WorldObject const *lootedObject) const
Definition PlayerStorage.cpp:1751
Player::GetSkillValue
uint16 GetSkillValue(uint32 skill) const
Definition Player.cpp:6563
Player::BankItem
Item * BankItem(ItemPosCountVec const &dest, Item *pItem, bool update)
Definition PlayerStorage.cpp:2212
Player::SendGameError
void SendGameError(GameError error, uint32 arg1=0, uint32 arg2=0)
Definition PlayerStorage.cpp:3325
Player::SplitItem
void SplitItem(uint16 src, uint16 dst, uint32 count)
Definition PlayerStorage.cpp:2707
Player::CanEquipUniqueItem
InventoryResult CanEquipUniqueItem(Item *pItem, uint8 except_slot=NULL_SLOT, uint32 limit_count=1) const
Definition PlayerStorage.cpp:3355
Player::GetItemByEntry
Item * GetItemByEntry(uint32 entry) const
Definition PlayerStorage.cpp:2660
Player::GetUseableItemByPos
Item * GetUseableItemByPos(uint8 bag, uint8 slot) const
Definition PlayerStorage.cpp:141
Player::CanStoreItem
InventoryResult CanStoreItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, Item *pItem, bool swap=false) const
Definition PlayerStorage.cpp:506
Player::HasItemCount
bool HasItemCount(uint32 item, uint32 count=1, bool inBankAlso=false) const
Definition PlayerStorage.cpp:311
Player::GetBankBagSlotCount
uint8 GetBankBagSlotCount() const
Definition Player.h:1552
Player::RemoveItemFromBuyBackSlot
void RemoveItemFromBuyBackSlot(uint32 slot, bool del)
Definition PlayerStorage.cpp:3240
Player::HasItemOrGemWithIdEquipped
bool HasItemOrGemWithIdEquipped(uint32 item, uint32 count, uint8 except_slot=NULL_SLOT) const
Definition PlayerStorage.cpp:375
Player::EquipNewItem
Item * EquipNewItem(uint16 pos, uint32 item, bool update)
Definition PlayerStorage.cpp:2010
Player::AddItemToBuyBackSlot
void AddItemToBuyBackSlot(Item *pItem)
Definition PlayerStorage.cpp:3178
Player::RecalculateRating
void RecalculateRating(CombatRating cr)
Definition Player.h:2352
Player::AddEnchantmentDurations
void AddEnchantmentDurations(Item *item)
Definition Player.cpp:10818
Player::CanTitanGrip
bool CanTitanGrip() const
Definition Player.h:2616
Player::SwapItem
void SwapItem(uint16 src, uint16 dst)
Definition PlayerStorage.cpp:2822
Player::HasItemOrGemWithLimitCategoryEquipped
bool HasItemOrGemWithLimitCategoryEquipped(uint32 limitCategory, uint32 count, uint8 except_slot=NULL_SLOT) const
Definition PlayerStorage.cpp:413
Player::GetLootGUID
uint64 GetLootGUID() const
Definition Player.h:2393
Player::IsTwoHandUsed
bool IsTwoHandUsed() const
Definition PlayerStorage.cpp:3349
Player::CanStoreItems
InventoryResult CanStoreItems(Item **pItem, int count) const
Definition PlayerStorage.cpp:995
Player::RemoveTradeableItem
void RemoveTradeableItem(Item *item)
Definition PlayerTrade.cpp:59
Player::_StoreItem
Item * _StoreItem(uint16 pos, Item *pItem, uint32 count, bool clone, bool update)
Definition PlayerStorage.cpp:1902
Player::StoreItem
Item * StoreItem(ItemPosCountVec const &pos, Item *pItem, bool update)
Definition PlayerStorage.cpp:1877
Player::GetSession
WorldSession * GetSession() const
Definition Player.h:2417
Player::GetItemByGuid
Item * GetItemByGuid(uint64 guid) const
Definition PlayerStorage.cpp:95
Player::DestroyConjuredItems
void DestroyConjuredItems(bool update)
Definition PlayerStorage.cpp:2633
Player::GetItemByPos
Item * GetItemByPos(uint16 pos) const
Definition PlayerStorage.cpp:124
Player::HasSkill
bool HasSkill(uint32 skill) const
Definition Player.cpp:6542
Player::UpdateExpertise
void UpdateExpertise(WeaponAttackType attType)
Definition StatSystem.cpp:694
Player::m_currentBuybackSlot
uint32 m_currentBuybackSlot
Definition Player.h:3368
Player::CanTakeMoreSimilarItems
InventoryResult CanTakeMoreSimilarItems(Item *pItem) const
Definition Player.h:1565
Player::GetItemCount
uint32 GetItemCount(uint32 item, bool inBankAlso=false, Item *skipItem=NULL) const
Definition PlayerStorage.cpp:27
Player::DestroyItem
void DestroyItem(uint8 bag, uint8 slot, bool update)
Definition PlayerStorage.cpp:2343
Player::MoveItemFromInventory
void MoveItemFromInventory(uint8 bag, uint8 slot, bool update)
Definition PlayerStorage.cpp:2301
Player::IsInventoryPos
static bool IsInventoryPos(uint16 pos)
Definition Player.h:1531
Player::m_weaponChangeTimer
uint32 m_weaponChangeTimer
Definition Player.h:3446
Player::_ApplyItemMods
void _ApplyItemMods(Item *item, uint8 slot, bool apply)
Definition Player.cpp:8399
Player::GetGlobalCooldownMgr
GlobalCooldownMgr & GetGlobalCooldownMgr()
Definition Player.h:2180
Player::MoveItemToInventory
void MoveItemToInventory(ItemPosCountVec const &dest, Item *pItem, bool update, bool in_characterInventoryDB=false)
Definition PlayerStorage.cpp:2318
Player::GetShield
Item * GetShield(bool useable=false) const
Definition PlayerStorage.cpp:190
Player::GetBattleground
Battleground * GetBattleground() const
Definition Player.cpp:19212
Player::FindEquipSlot
uint8 FindEquipSlot(ItemTemplate const *proto, uint32 slot, bool swap) const
Definition Player.cpp:10499
Player::GetTradeData
TradeData * GetTradeData() const
Definition Player.h:1694
Player::GetGroup
Group * GetGroup()
Definition Player.h:2972
Player::SendRefundInfo
void SendRefundInfo(Item *item)
Definition Player.cpp:22163
Player::AutoUnequipOffhandIfNeed
void AutoUnequipOffhandIfNeed(bool force=false)
Definition Player.cpp:19517
Player::RemoveEnchantmentDurations
void RemoveEnchantmentDurations(Item *item)
Definition Player.cpp:10834
Player::UpdateAchievementCriteria
void UpdateAchievementCriteria(AchievementCriteriaTypes type, uint64 miscValue1=0, uint64 miscValue2=0, uint64 miscValue3=0, Unit *unit=NULL)
Definition Player.cpp:21033
Player::CanStoreNewItem
InventoryResult CanStoreNewItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, uint32 item, uint32 count, uint32 *no_space_count=NULL) const
Definition PlayerStorage.cpp:501
Player::EquipItem
Item * EquipItem(uint16 pos, Item *pItem, bool update)
Definition PlayerStorage.cpp:2022
Player::m_items
Item * m_items[PLAYER_SLOTS_COUNT]
Definition Player.h:3367
Player::AddItemDurations
void AddItemDurations(Item *item)
Definition Player.cpp:19508
Player::IsBagPos
static bool IsBagPos(uint16 pos)
Definition PlayerStorage.cpp:250
Player::ApplyEquipCooldown
void ApplyEquipCooldown(Item *pItem)
Definition Player.cpp:18751
Player::CanStoreItem_InInventorySlots
InventoryResult CanStoreItem_InInventorySlots(uint8 slot_begin, uint8 slot_end, ItemPosCountVec &dest, ItemTemplate const *pProto, uint32 &count, bool merge, Item *pSrcItem, uint8 skip_bag, uint8 skip_slot) const
Definition PlayerStorage.cpp:650
Player::DestroyItemCount
void DestroyItemCount(uint32 item, uint32 count, bool update, bool unequip_check=false)
Definition PlayerStorage.cpp:2445
Player::AddTradeableItem
void AddTradeableItem(Item *item)
Definition PlayerTrade.cpp:53
Player::m_logintime
time_t m_logintime
Definition Player.h:1421
Player::GetItemFromBuyBackSlot
Item * GetItemFromBuyBackSlot(uint32 slot)
Definition PlayerStorage.cpp:3232
Player::RemoveItemDurations
void RemoveItemDurations(Item *item)
Definition Player.cpp:19496
Player::CanStoreItem_InBag
InventoryResult CanStoreItem_InBag(uint8 bag, ItemPosCountVec &dest, ItemTemplate const *pProto, uint32 &count, bool merge, bool non_specialized, Item *pSrcItem, uint8 skip_bag, uint8 skip_slot) const
Definition PlayerStorage.cpp:580
Player::CanBankItem
InventoryResult CanBankItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, Item *pItem, bool swap, bool not_loading=true) const
Definition PlayerStorage.cpp:1468
Player::GetItemCountWithLimitCategory
uint32 GetItemCountWithLimitCategory(uint32 limitCategory, Item *skipItem=NULL) const
Definition PlayerStorage.cpp:67
Player::GetReputationRank
ReputationRank GetReputationRank(uint32 faction_id) const
Definition Player.cpp:7098
Player::CanUnequipItems
InventoryResult CanUnequipItems(uint32 item, uint32 count) const
Definition PlayerStorage.cpp:1205
Player::ItemAddedQuestCheck
void ItemAddedQuestCheck(uint32 entry, uint32 count)
Definition PlayerQuestState.cpp:1610
Player::GetWeaponForAttack
Item * GetWeaponForAttack(WeaponAttackType attackType, bool useable=false) const
Definition PlayerStorage.cpp:157
Player::IsUseEquipedWeapon
bool IsUseEquipedWeapon(bool mainhand) const
Definition PlayerStorage.cpp:3343
Player::StoreNewItem
Item * StoreNewItem(ItemPosCountVec const &pos, uint32 item, bool update, int32 randomPropertyId=0, AllowedLooterSet const &allowedLooters=AllowedLooterSet())
Definition PlayerStorage.cpp:1839
Player::IsBankPos
static bool IsBankPos(uint16 pos)
Definition Player.h:1542
Player::RemoveItem
void RemoveItem(uint8 bag, uint8 slot, bool update)
Definition PlayerStorage.cpp:2217
Player::HasSpell
bool HasSpell(uint32 spell) const override
Definition Player.cpp:4674
Player::m_session
WorldSession * m_session
Definition Player.h:3430
Player::VisualizeItem
void VisualizeItem(uint8 slot, Item *pItem)
Definition PlayerStorage.cpp:2188
Player::CanStoreItem_InSpecificSlot
InventoryResult CanStoreItem_InSpecificSlot(uint8 bag, uint8 slot, ItemPosCountVec &dest, ItemTemplate const *pProto, uint32 &count, bool swap, Item *pSrcItem) const
Definition PlayerStorage.cpp:514
Player::SetVisibleItemSlot
void SetVisibleItemSlot(uint8 slot, Item *pItem)
Definition PlayerStorage.cpp:2173
Player::GetAttackBySlot
static WeaponAttackType GetAttackBySlot(uint8 slot)
Definition PlayerStorage.cpp:209
Player::DestroyZoneLimitedItem
void DestroyZoneLimitedItem(bool update, uint32 new_zone)
Definition PlayerStorage.cpp:2608
Player::IsValidPos
bool IsValidPos(uint16 pos, bool explicit_pos)
Definition Player.h:1547
Player::CanUseItem
InventoryResult CanUseItem(Item *pItem, bool not_loading=true) const
Definition PlayerStorage.cpp:1654
PreparedStatement::setString
void setString(const uint8 index, const std::string &value)
Definition PreparedStatement.cpp:175
PreparedStatement::setUInt32
void setUInt32(const uint8 index, const uint32 value)
Definition PreparedStatement.cpp:103
SpellInfo::StartRecoveryTime
uint32 StartRecoveryTime
Definition SpellInfo.h:197
Unit::IsNonMeleeSpellCasted
bool IsNonMeleeSpellCasted(bool withDelayed, bool skipChanneled=false, bool skipAutorepeat=false, bool isAutoshoot=false, bool skipInstant=true) const
Definition Unit.cpp:1402
Unit::CastSpell
void CastSpell(SpellCastTargets const &targets, SpellInfo const *spellInfo, CustomSpellValues const *value, TriggerCastFlags triggerFlags=TRIGGERED_NONE, Item *castItem=NULL, AuraEffect const *triggeredByAura=NULL, uint64 originalCaster=0)
Definition UnitCombat.cpp:324
Unit::RemoveAurasDueToSpell
void RemoveAurasDueToSpell(uint32 spellId, uint64 casterGUID=0, uint32 reqEffMask=0, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
Definition UnitAuraState.cpp:532
Unit::CanDualWield
bool CanDualWield() const
Definition Unit.h:1437
Unit::getClass
uint8 getClass() const
Definition Unit.h:1543
Unit::IsAlive
bool IsAlive() const
Definition Unit.h:2032
Unit::HasAura
bool HasAura(uint32 spellId, uint64 casterGUID=0, uint64 itemCasterGUID=0, uint32 reqEffMask=0) const
Definition UnitAuraState.cpp:1182
Unit::CanUseAttackType
bool CanUseAttackType(WeaponAttackType attacktype) const
Definition Unit.cpp:744
Unit::getRaceMask
uint32 getRaceMask() const
Definition Unit.h:1539
Unit::HasUnitState
bool HasUnitState(const uint32 f) const
Definition Unit.h:1485
Unit::getClassMask
uint32 getClassMask() const
Definition Unit.h:1547
Unit::IsInFeralForm
bool IsInFeralForm() const
Definition Unit.cpp:4936
Unit::getLevel
uint8 getLevel() const
Definition Unit.h:1528
Unit::IsInCombat
bool IsInCombat() const
Definition Unit.h:1896
Unit::getRace
uint8 getRace() const
Definition Unit.h:1535
WorldLocation::GetMapId
uint32 GetMapId() const
Definition Object.h:546
WorldObject::GetMap
Map * GetMap() const
Definition Object.h:740
WorldObject::GetName
std::string const & GetName() const
Definition Object.h:664
WorldObject::WorldObject
WorldObject(bool isWorldObject)
Definition Object.cpp:1514
WorldSession::SendPacket
void SendPacket(WorldPacket const *packet, bool forced=false)
Send a packet to the client.
Definition WorldSession.cpp:196
CharacterDatabase
CharacterDatabaseWorkerPool CharacterDatabase
Accessor to the character database.
Definition Main.cpp:41
SMSG_DISPLAY_GAME_ERROR
@ SMSG_DISPLAY_GAME_ERROR
Definition Opcodes.h:639
SMSG_SPELL_COOLDOWN
@ SMSG_SPELL_COOLDOWN
Definition Opcodes.h:979
SMSG_INVENTORY_CHANGE_FAILURE
@ SMSG_INVENTORY_CHANGE_FAILURE
Definition Opcodes.h:727
_Socket::Color
uint32 Color
Definition ItemPrototype.h:611
_Spell::SpellTrigger
uint32 SpellTrigger
Definition ItemPrototype.h:602
_Spell::SpellId
int32 SpellId
Definition ItemPrototype.h:601
ItemLimitCategoryEntry
Definition DBCStructure.h:1842
ItemLimitCategoryEntry::maxCount
uint32 maxCount
Definition DBCStructure.h:1845
ItemLimitCategoryEntry::mode
uint32 mode
Definition DBCStructure.h:1846
ItemPosCount::isContainedIn
bool isContainedIn(std::vector< ItemPosCount > const &vec) const
Definition Player.cpp:20254
ItemTemplate::CanChangeEquipStateInCombat
bool CanChangeEquipStateInCombat() const
Definition ItemPrototype.h:716
ItemTemplate::RequiredSkill
uint32 RequiredSkill
Definition ItemPrototype.h:658
ItemTemplate::RequiredSpell
uint32 RequiredSpell
Definition ItemPrototype.h:660
ItemTemplate::AllowableClass
uint32 AllowableClass
Definition ItemPrototype.h:654
ItemTemplate::RequiredSkillRank
uint32 RequiredSkillRank
Definition ItemPrototype.h:659
ItemTemplate::GetMaxStackSize
uint32 GetMaxStackSize() const
Definition ItemPrototype.h:738
ItemTemplate::Spells
_Spell Spells[MAX_ITEM_PROTO_SPELLS]
Definition ItemPrototype.h:673
ItemTemplate::RequiredLevel
uint32 RequiredLevel
Definition ItemPrototype.h:657
ItemTemplate::GemProperties
uint32 GemProperties
Definition ItemPrototype.h:693
ItemTemplate::RequiredReputationRank
uint32 RequiredReputationRank
Definition ItemPrototype.h:664
ItemTemplate::ContainerSlots
uint32 ContainerSlots
Definition ItemPrototype.h:667
ItemTemplate::AllowableRace
uint32 AllowableRace
Definition ItemPrototype.h:655
ItemTemplate::RequiredReputationFaction
uint32 RequiredReputationFaction
Definition ItemPrototype.h:663
ItemTemplate::ItemLimitCategory
uint32 ItemLimitCategory
Definition ItemPrototype.h:696
ItemTemplate::ScalingStatDistribution
uint32 ScalingStatDistribution
Definition ItemPrototype.h:669
ItemTemplate::InventoryType
uint32 InventoryType
Definition ItemPrototype.h:653
ItemTemplate::Socket
_Socket Socket[MAX_ITEM_PROTO_SOCKETS]
Definition ItemPrototype.h:691
ScalingStatDistributionEntry
Definition DBCStructure.h:2182
ScalingStatDistributionEntry::MaxLevel
uint32 MaxLevel
Definition DBCStructure.h:2187
SpellItemEnchantmentEntry
Definition DBCStructure.h:2676
SpellItemEnchantmentEntry::GemID
uint32 GemID
Definition DBCStructure.h:2685