src/game/Item.cpp

   1 /*
   2  * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "Common.h"
  20 #include "Item.h"
  21 #include "ObjectMgr.h"
  22 #include "ObjectGuid.h"
  23 #include "WorldPacket.h"
  24 #include "Database/DatabaseEnv.h"
  25 #include "ItemEnchantmentMgr.h"
  26
  27 void AddItemsSetItem(Player*player,Item *item)
  28 {
  29     ItemPrototype const *proto = item->GetProto();
  30     uint32 setid = proto->ItemSet;
  31
  32     ItemSetEntry const *set = sItemSetStore.LookupEntry(setid);
  33
  34     if(!set)
  35     {
  36         sLog.outErrorDb("Item set %u for item (id %u) not found, mods not applied.",setid,proto->ItemId);
  37         return;
  38     }
  39
  40     if( set->required_skill_id && player->GetSkillValue(set->required_skill_id) < set->required_skill_value )
  41         return;
  42
  43     ItemSetEffect *eff = NULL;
  44
  45     for(size_t x = 0; x < player->ItemSetEff.size(); ++x)
  46     {
  47         if(player->ItemSetEff[x] && player->ItemSetEff[x]->setid == setid)
  48         {
  49             eff = player->ItemSetEff[x];
  50             break;
  51         }
  52     }
  53
  54     if(!eff)
  55     {
  56         eff = new ItemSetEffect;
  57         memset(eff,0,sizeof(ItemSetEffect));
  58         eff->setid = setid;
  59
  60         size_t x = 0;
  61         for(; x < player->ItemSetEff.size(); x++)
  62             if(!player->ItemSetEff[x])
  63                 break;
  64
  65         if(x < player->ItemSetEff.size())
  66             player->ItemSetEff[x]=eff;
  67         else
  68             player->ItemSetEff.push_back(eff);
  69     }
  70
  71     ++eff->item_count;
  72
  73     for(uint32 x=0;x<8;x++)
  74     {
  75         if(!set->spells [x])
  76             continue;
  77         //not enough for  spell
  78         if(set->items_to_triggerspell[x] > eff->item_count)
  79             continue;
  80
  81         uint32 z=0;
  82         for(;z<8;z++)
  83             if(eff->spells[z] && eff->spells[z]->Id==set->spells[x])
  84                 break;
  85
  86         if(z < 8)
  87             continue;
  88
  89         //new spell
  90         for(uint32 y=0;y<8;y++)
  91         {
  92             if(!eff->spells[y])                             // free slot
  93             {
  94                 SpellEntry const *spellInfo = sSpellStore.LookupEntry(set->spells[x]);
  95                 if(!spellInfo)
  96                 {
  97                     sLog.outError("WORLD: unknown spell id %u in items set %u effects", set->spells[x],setid);
  98                     break;
  99                 }
 100
 101                 // spell casted only if fit form requirement, in other case will casted at form change
 102                 player->ApplyEquipSpell(spellInfo,NULL,true);
 103                 eff->spells[y] = spellInfo;
 104                 break;
 105             }
 106         }
 107     }
 108 }
 109
 110 void RemoveItemsSetItem(Player*player,ItemPrototype const *proto)
 111 {
 112     uint32 setid = proto->ItemSet;
 113
 114     ItemSetEntry const *set = sItemSetStore.LookupEntry(setid);
 115
 116     if(!set)
 117     {
 118         sLog.outErrorDb("Item set #%u for item #%u not found, mods not removed.",setid,proto->ItemId);
 119         return;
 120     }
 121
 122     ItemSetEffect *eff = NULL;
 123     size_t setindex = 0;
 124     for(;setindex < player->ItemSetEff.size(); setindex++)
 125     {
 126         if(player->ItemSetEff[setindex] && player->ItemSetEff[setindex]->setid == setid)
 127         {
 128             eff = player->ItemSetEff[setindex];
 129             break;
 130         }
 131     }
 132
 133     // can be in case now enough skill requirement for set appling but set has been appliend when skill requirement not enough
 134     if(!eff)
 135         return;
 136
 137     --eff->item_count;
 138
 139     for(uint32 x=0;x<8;x++)
 140     {
 141         if(!set->spells[x])
 142             continue;
 143
 144         // enough for spell
 145         if(set->items_to_triggerspell[x] <= eff->item_count)
 146             continue;
 147
 148         for(uint32 z=0;z<8;z++)
 149         {
 150             if(eff->spells[z] && eff->spells[z]->Id==set->spells[x])
 151             {
 152                 // spell can be not active if not fit form requirement
 153                 player->ApplyEquipSpell(eff->spells[z],NULL,false);
 154                 eff->spells[z]=NULL;
 155                 break;
 156             }
 157         }
 158     }
 159
 160     if(!eff->item_count)                                    //all items of a set were removed
 161     {
 162         assert(eff == player->ItemSetEff[setindex]);
 163         delete eff;
 164         player->ItemSetEff[setindex] = NULL;
 165     }
 166 }
 167
 168 bool ItemCanGoIntoBag(ItemPrototype const *pProto, ItemPrototype const *pBagProto)
 169 {
 170     if(!pProto || !pBagProto)
 171         return false;
 172
 173     switch(pBagProto->Class)
 174     {
 175         case ITEM_CLASS_CONTAINER:
 176             switch(pBagProto->SubClass)
 177             {
 178                 case ITEM_SUBCLASS_CONTAINER:
 179                     return true;
 180                 case ITEM_SUBCLASS_SOUL_CONTAINER:
 181                     if(!(pProto->BagFamily & BAG_FAMILY_MASK_SOUL_SHARDS))
 182                         return false;
 183                     return true;
 184                 case ITEM_SUBCLASS_HERB_CONTAINER:
 185                     if(!(pProto->BagFamily & BAG_FAMILY_MASK_HERBS))
 186                         return false;
 187                     return true;
 188                 case ITEM_SUBCLASS_ENCHANTING_CONTAINER:
 189                     if(!(pProto->BagFamily & BAG_FAMILY_MASK_ENCHANTING_SUPP))
 190                         return false;
 191                     return true;
 192                 case ITEM_SUBCLASS_MINING_CONTAINER:
 193                     if(!(pProto->BagFamily & BAG_FAMILY_MASK_MINING_SUPP))
 194                         return false;
 195                     return true;
 196                 case ITEM_SUBCLASS_ENGINEERING_CONTAINER:
 197                     if(!(pProto->BagFamily & BAG_FAMILY_MASK_ENGINEERING_SUPP))
 198                         return false;
 199                     return true;
 200                 case ITEM_SUBCLASS_GEM_CONTAINER:
 201                     if(!(pProto->BagFamily & BAG_FAMILY_MASK_GEMS))
 202                         return false;
 203                     return true;
 204                 case ITEM_SUBCLASS_LEATHERWORKING_CONTAINER:
 205                     if(!(pProto->BagFamily & BAG_FAMILY_MASK_LEATHERWORKING_SUPP))
 206                         return false;
 207                     return true;
 208                 case ITEM_SUBCLASS_INSCRIPTION_CONTAINER:
 209                     if(!(pProto->BagFamily & BAG_FAMILY_MASK_INSCRIPTION_SUPP))
 210                         return false;
 211                     return true;
 212                 default:
 213                     return false;
 214             }
 215         case ITEM_CLASS_QUIVER:
 216             switch(pBagProto->SubClass)
 217             {
 218                 case ITEM_SUBCLASS_QUIVER:
 219                     if(!(pProto->BagFamily & BAG_FAMILY_MASK_ARROWS))
 220                         return false;
 221                     return true;
 222                 case ITEM_SUBCLASS_AMMO_POUCH:
 223                     if(!(pProto->BagFamily & BAG_FAMILY_MASK_BULLETS))
 224                         return false;
 225                     return true;
 226                 default:
 227                     return false;
 228             }
 229     }
 230     return false;
 231 }
 232
 233 Item::Item( )
 234 {
 235     m_objectType |= TYPEMASK_ITEM;
 236     m_objectTypeId = TYPEID_ITEM;
 237
 238     m_updateFlag = UPDATEFLAG_HIGHGUID;
 239
 240     m_valuesCount = ITEM_END;
 241     m_slot = 0;
 242     uState = ITEM_NEW;
 243     uQueuePos = -1;
 244     m_container = NULL;
 245     m_lootGenerated = false;
 246     mb_in_trade = false;
 247 }
 248
 249 bool Item::Create( uint32 guidlow, uint32 itemid, Player const* owner)
 250 {
 251     Object::_Create( guidlow, 0, HIGHGUID_ITEM );
 252
 253     SetEntry(itemid);
 254     SetFloatValue(OBJECT_FIELD_SCALE_X, 1.0f);
 255
 256     SetUInt64Value(ITEM_FIELD_OWNER, owner ? owner->GetGUID() : 0);
 257     SetUInt64Value(ITEM_FIELD_CONTAINED, owner ? owner->GetGUID() : 0);
 258
 259     ItemPrototype const *itemProto = ObjectMgr::GetItemPrototype(itemid);
 260     if(!itemProto)
 261         return false;
 262
 263     SetUInt32Value(ITEM_FIELD_STACK_COUNT, 1);
 264     SetUInt32Value(ITEM_FIELD_MAXDURABILITY, itemProto->MaxDurability);
 265     SetUInt32Value(ITEM_FIELD_DURABILITY, itemProto->MaxDurability);
 266
 267     for(int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
 268         SetSpellCharges(i,itemProto->Spells[i].SpellCharges);
 269
 270     SetUInt32Value(ITEM_FIELD_FLAGS, itemProto->Flags);
 271     SetUInt32Value(ITEM_FIELD_DURATION, itemProto->Duration);
 272
 273     return true;
 274 }
 275
 276 void Item::UpdateDuration(Player* owner, uint32 diff)
 277 {
 278     if (!GetUInt32Value(ITEM_FIELD_DURATION))
 279         return;
 280
 281     sLog.outDebug("Item::UpdateDuration Item (Entry: %u Duration %u Diff %u)",GetEntry(),GetUInt32Value(ITEM_FIELD_DURATION),diff);
 282
 283     if (GetUInt32Value(ITEM_FIELD_DURATION)<=diff)
 284     {
 285         owner->DestroyItem(GetBagSlot(), GetSlot(), true);
 286         return;
 287     }
 288
 289     SetUInt32Value(ITEM_FIELD_DURATION, GetUInt32Value(ITEM_FIELD_DURATION) - diff);
 290     SetState(ITEM_CHANGED, owner);                          // save new time in database
 291 }
 292
 293 void Item::SaveToDB()
 294 {
 295     uint32 guid = GetGUIDLow();
 296     switch (uState)
 297     {
 298         case ITEM_NEW:
 299         {
 300             CharacterDatabase.PExecute( "DELETE FROM item_instance WHERE guid = '%u'", guid );
 301             std::ostringstream ss;
 302             ss << "INSERT INTO item_instance (guid,owner_guid,data) VALUES (" << guid << "," << GUID_LOPART(GetOwnerGUID()) << ",'";
 303             for(uint16 i = 0; i < m_valuesCount; ++i )
 304                 ss << GetUInt32Value(i) << " ";
 305             ss << "' )";
 306             CharacterDatabase.Execute( ss.str().c_str() );
 307         } break;
 308         case ITEM_CHANGED:
 309         {
 310             std::ostringstream ss;
 311             ss << "UPDATE item_instance SET data = '";
 312             for(uint16 i = 0; i < m_valuesCount; ++i )
 313                 ss << GetUInt32Value(i) << " ";
 314             ss << "', owner_guid = '" << GUID_LOPART(GetOwnerGUID()) << "' WHERE guid = '" << guid << "'";
 315
 316             CharacterDatabase.Execute( ss.str().c_str() );
 317
 318             if(HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_WRAPPED))
 319                 CharacterDatabase.PExecute("UPDATE character_gifts SET guid = '%u' WHERE item_guid = '%u'", GUID_LOPART(GetOwnerGUID()),GetGUIDLow());
 320         } break;
 321         case ITEM_REMOVED:
 322         {
 323             if (GetUInt32Value(ITEM_FIELD_ITEM_TEXT_ID) > 0 )
 324                 CharacterDatabase.PExecute("DELETE FROM item_text WHERE id = '%u'", GetUInt32Value(ITEM_FIELD_ITEM_TEXT_ID));
 325             CharacterDatabase.PExecute("DELETE FROM item_instance WHERE guid = '%u'", guid);
 326             if(HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_WRAPPED))
 327                 CharacterDatabase.PExecute("DELETE FROM character_gifts WHERE item_guid = '%u'", GetGUIDLow());
 328             delete this;
 329             return;
 330         }
 331         case ITEM_UNCHANGED:
 332             break;
 333     }
 334     SetState(ITEM_UNCHANGED);
 335 }
 336
 337 bool Item::LoadFromDB(uint32 guid, uint64 owner_guid, QueryResult *result)
 338 {
 339     // create item before any checks for store correct guid
 340     // and allow use "FSetState(ITEM_REMOVED); SaveToDB();" for deleting item from DB
 341     Object::_Create(guid, 0, HIGHGUID_ITEM);
 342
 343     bool delete_result = false;
 344     if(!result)
 345     {
 346         result = CharacterDatabase.PQuery("SELECT data FROM item_instance WHERE guid = '%u'", guid);
 347         delete_result = true;
 348     }
 349
 350     if (!result)
 351     {
 352         sLog.outError("Item (GUID: %u owner: %u) not found in table `item_instance`, can't load. ",guid,GUID_LOPART(owner_guid));
 353         return false;
 354     }
 355
 356     Field *fields = result->Fetch();
 357
 358     if(!LoadValues(fields[0].GetString()))
 359     {
 360         sLog.outError("Item #%d have broken data in `data` field. Can't be loaded.",guid);
 361         if (delete_result) delete result;
 362         return false;
 363     }
 364
 365     bool need_save = false;                                 // need explicit save data at load fixes
 366
 367     // overwrite possible wrong/corrupted guid
 368     uint64 new_item_guid = MAKE_NEW_GUID(guid,0, HIGHGUID_ITEM);
 369     if(GetUInt64Value(OBJECT_FIELD_GUID) != new_item_guid)
 370     {
 371         SetUInt64Value(OBJECT_FIELD_GUID, MAKE_NEW_GUID(guid,0, HIGHGUID_ITEM));
 372         need_save = true;
 373     }
 374
 375     if (delete_result) delete result;
 376
 377     ItemPrototype const* proto = GetProto();
 378     if(!proto)
 379         return false;
 380
 381     // update max durability (and durability) if need
 382     if(proto->MaxDurability!= GetUInt32Value(ITEM_FIELD_MAXDURABILITY))
 383     {
 384         SetUInt32Value(ITEM_FIELD_MAXDURABILITY,proto->MaxDurability);
 385         if(GetUInt32Value(ITEM_FIELD_DURABILITY) > proto->MaxDurability)
 386             SetUInt32Value(ITEM_FIELD_DURABILITY,proto->MaxDurability);
 387
 388         need_save = true;
 389     }
 390
 391     // recalculate suffix factor
 392     if(GetItemRandomPropertyId() < 0)
 393     {
 394         if(UpdateItemSuffixFactor())
 395             need_save = true;
 396     }
 397
 398     // Remove bind flag for items vs NO_BIND set
 399     if (IsSoulBound() && proto->Bonding == NO_BIND)
 400     {
 401         ApplyModFlag(ITEM_FIELD_FLAGS,ITEM_FLAGS_BINDED, false);
 402         need_save = true;
 403     }
 404
 405     // update duration if need, and remove if not need
 406     if ((proto->Duration == 0) != (GetUInt32Value(ITEM_FIELD_DURATION) == 0))
 407     {
 408         SetUInt32Value(ITEM_FIELD_DURATION, proto->Duration);
 409         need_save = true;
 410     }
 411
 412     // set correct owner
 413     if (owner_guid != 0 && GetOwnerGUID() != owner_guid)
 414     {
 415         SetOwnerGUID(owner_guid);
 416         need_save = true;
 417     }
 418
 419     if (need_save)                                          // normal item changed state set not work at loading
 420     {
 421         std::ostringstream ss;
 422         ss << "UPDATE item_instance SET data = '";
 423         for(uint16 i = 0; i < m_valuesCount; ++i )
 424             ss << GetUInt32Value(i) << " ";
 425         ss << "', owner_guid = '" << GUID_LOPART(GetOwnerGUID()) << "' WHERE guid = '" << guid << "'";
 426
 427         CharacterDatabase.Execute( ss.str().c_str() );
 428     }
 429
 430     return true;
 431 }
 432
 433 void Item::DeleteFromDB()
 434 {
 435     CharacterDatabase.PExecute("DELETE FROM item_instance WHERE guid = '%u'",GetGUIDLow());
 436 }
 437
 438 void Item::DeleteFromInventoryDB()
 439 {
 440     CharacterDatabase.PExecute("DELETE FROM character_inventory WHERE item = '%u'",GetGUIDLow());
 441 }
 442
 443 ItemPrototype const *Item::GetProto() const
 444 {
 445     return ObjectMgr::GetItemPrototype(GetEntry());
 446 }
 447
 448 Player* Item::GetOwner()const
 449 {
 450     return sObjectMgr.GetPlayer(GetOwnerGUID());
 451 }
 452
 453 uint32 Item::GetSkill()
 454 {
 455     const static uint32 item_weapon_skills[MAX_ITEM_SUBCLASS_WEAPON] =
 456     {
 457         SKILL_AXES,     SKILL_2H_AXES,  SKILL_BOWS,          SKILL_GUNS,      SKILL_MACES,
 458         SKILL_2H_MACES, SKILL_POLEARMS, SKILL_SWORDS,        SKILL_2H_SWORDS, 0,
 459         SKILL_STAVES,   0,              0,                   SKILL_UNARMED,   0,
 460         SKILL_DAGGERS,  SKILL_THROWN,   SKILL_ASSASSINATION, SKILL_CROSSBOWS, SKILL_WANDS,
 461         SKILL_FISHING
 462     };
 463
 464     const static uint32 item_armor_skills[MAX_ITEM_SUBCLASS_ARMOR] =
 465     {
 466         0,SKILL_CLOTH,SKILL_LEATHER,SKILL_MAIL,SKILL_PLATE_MAIL,0,SKILL_SHIELD,0,0,0,0
 467     };
 468
 469     ItemPrototype const* proto = GetProto();
 470
 471     switch (proto->Class)
 472     {
 473         case ITEM_CLASS_WEAPON:
 474             if( proto->SubClass >= MAX_ITEM_SUBCLASS_WEAPON )
 475                 return 0;
 476             else
 477                 return item_weapon_skills[proto->SubClass];
 478
 479         case ITEM_CLASS_ARMOR:
 480             if( proto->SubClass >= MAX_ITEM_SUBCLASS_ARMOR )
 481                 return 0;
 482             else
 483                 return item_armor_skills[proto->SubClass];
 484
 485         default:
 486             return 0;
 487     }
 488 }
 489
 490 uint32 Item::GetSpell()
 491 {
 492     ItemPrototype const* proto = GetProto();
 493
 494     switch (proto->Class)
 495     {
 496         case ITEM_CLASS_WEAPON:
 497             switch (proto->SubClass)
 498             {
 499                 case ITEM_SUBCLASS_WEAPON_AXE:     return  196;
 500                 case ITEM_SUBCLASS_WEAPON_AXE2:    return  197;
 501                 case ITEM_SUBCLASS_WEAPON_BOW:     return  264;
 502                 case ITEM_SUBCLASS_WEAPON_GUN:     return  266;
 503                 case ITEM_SUBCLASS_WEAPON_MACE:    return  198;
 504                 case ITEM_SUBCLASS_WEAPON_MACE2:   return  199;
 505                 case ITEM_SUBCLASS_WEAPON_POLEARM: return  200;
 506                 case ITEM_SUBCLASS_WEAPON_SWORD:   return  201;
 507                 case ITEM_SUBCLASS_WEAPON_SWORD2:  return  202;
 508                 case ITEM_SUBCLASS_WEAPON_STAFF:   return  227;
 509                 case ITEM_SUBCLASS_WEAPON_DAGGER:  return 1180;
 510                 case ITEM_SUBCLASS_WEAPON_THROWN:  return 2567;
 511                 case ITEM_SUBCLASS_WEAPON_SPEAR:   return 3386;
 512                 case ITEM_SUBCLASS_WEAPON_CROSSBOW:return 5011;
 513                 case ITEM_SUBCLASS_WEAPON_WAND:    return 5009;
 514                 default: return 0;
 515             }
 516         case ITEM_CLASS_ARMOR:
 517             switch(proto->SubClass)
 518             {
 519                 case ITEM_SUBCLASS_ARMOR_CLOTH:    return 9078;
 520                 case ITEM_SUBCLASS_ARMOR_LEATHER:  return 9077;
 521                 case ITEM_SUBCLASS_ARMOR_MAIL:     return 8737;
 522                 case ITEM_SUBCLASS_ARMOR_PLATE:    return  750;
 523                 case ITEM_SUBCLASS_ARMOR_SHIELD:   return 9116;
 524                 default: return 0;
 525             }
 526     }
 527     return 0;
 528 }
 529
 530 int32 Item::GenerateItemRandomPropertyId(uint32 item_id)
 531 {
 532     ItemPrototype const *itemProto = sItemStorage.LookupEntry<ItemPrototype>(item_id);
 533
 534     if(!itemProto)
 535         return 0;
 536
 537     // item must have one from this field values not null if it can have random enchantments
 538     if((!itemProto->RandomProperty) && (!itemProto->RandomSuffix))
 539         return 0;
 540
 541     // item can have not null only one from field values
 542     if((itemProto->RandomProperty) && (itemProto->RandomSuffix))
 543     {
 544         sLog.outErrorDb("Item template %u have RandomProperty==%u and RandomSuffix==%u, but must have one from field =0",itemProto->ItemId,itemProto->RandomProperty,itemProto->RandomSuffix);
 545         return 0;
 546     }
 547
 548     // RandomProperty case
 549     if(itemProto->RandomProperty)
 550     {
 551         uint32 randomPropId = GetItemEnchantMod(itemProto->RandomProperty);
 552         ItemRandomPropertiesEntry const *random_id = sItemRandomPropertiesStore.LookupEntry(randomPropId);
 553         if(!random_id)
 554         {
 555             sLog.outErrorDb("Enchantment id #%u used but it doesn't have records in 'ItemRandomProperties.dbc'",randomPropId);
 556             return 0;
 557         }
 558
 559         return random_id->ID;
 560     }
 561     // RandomSuffix case
 562     else
 563     {
 564         uint32 randomPropId = GetItemEnchantMod(itemProto->RandomSuffix);
 565         ItemRandomSuffixEntry const *random_id = sItemRandomSuffixStore.LookupEntry(randomPropId);
 566         if(!random_id)
 567         {
 568             sLog.outErrorDb("Enchantment id #%u used but it doesn't have records in sItemRandomSuffixStore.",randomPropId);
 569             return 0;
 570         }
 571
 572         return -int32(random_id->ID);
 573     }
 574 }
 575
 576 void Item::SetItemRandomProperties(int32 randomPropId)
 577 {
 578     if(!randomPropId)
 579         return;
 580
 581     if(randomPropId > 0)
 582     {
 583         ItemRandomPropertiesEntry const *item_rand = sItemRandomPropertiesStore.LookupEntry(randomPropId);
 584         if(item_rand)
 585         {
 586             if(GetInt32Value(ITEM_FIELD_RANDOM_PROPERTIES_ID) != int32(item_rand->ID))
 587             {
 588                 SetInt32Value(ITEM_FIELD_RANDOM_PROPERTIES_ID,item_rand->ID);
 589                 SetState(ITEM_CHANGED);
 590             }
 591             for(uint32 i = PROP_ENCHANTMENT_SLOT_2; i < PROP_ENCHANTMENT_SLOT_2 + 3; ++i)
 592                 SetEnchantment(EnchantmentSlot(i),item_rand->enchant_id[i - PROP_ENCHANTMENT_SLOT_2],0,0);
 593         }
 594     }
 595     else
 596     {
 597         ItemRandomSuffixEntry const *item_rand = sItemRandomSuffixStore.LookupEntry(-randomPropId);
 598         if(item_rand)
 599         {
 600             if( GetInt32Value(ITEM_FIELD_RANDOM_PROPERTIES_ID) != -int32(item_rand->ID) ||
 601                 !GetItemSuffixFactor())
 602             {
 603                 SetInt32Value(ITEM_FIELD_RANDOM_PROPERTIES_ID,-int32(item_rand->ID));
 604                 UpdateItemSuffixFactor();
 605                 SetState(ITEM_CHANGED);
 606             }
 607
 608             for(uint32 i = PROP_ENCHANTMENT_SLOT_0; i < PROP_ENCHANTMENT_SLOT_0 + 3; ++i)
 609                 SetEnchantment(EnchantmentSlot(i),item_rand->enchant_id[i - PROP_ENCHANTMENT_SLOT_0],0,0);
 610         }
 611     }
 612 }
 613
 614 bool Item::UpdateItemSuffixFactor()
 615 {
 616     uint32 suffixFactor = GenerateEnchSuffixFactor(GetEntry());
 617     if(GetItemSuffixFactor()==suffixFactor)
 618         return false;
 619     SetUInt32Value(ITEM_FIELD_PROPERTY_SEED,suffixFactor);
 620     return true;
 621 }
 622
 623 void Item::SetState(ItemUpdateState state, Player *forplayer)
 624 {
 625     if (uState == ITEM_NEW && state == ITEM_REMOVED)
 626     {
 627         // pretend the item never existed
 628         RemoveFromUpdateQueueOf(forplayer);
 629         delete this;
 630         return;
 631     }
 632
 633     if (state != ITEM_UNCHANGED)
 634     {
 635         // new items must stay in new state until saved
 636         if (uState != ITEM_NEW) uState = state;
 637         AddToUpdateQueueOf(forplayer);
 638     }
 639     else
 640     {
 641         // unset in queue
 642         // the item must be removed from the queue manually
 643         uQueuePos = -1;
 644         uState = ITEM_UNCHANGED;
 645     }
 646 }
 647
 648 void Item::AddToUpdateQueueOf(Player *player)
 649 {
 650     if (IsInUpdateQueue()) return;
 651
 652     if (!player)
 653     {
 654         player = GetOwner();
 655         if (!player)
 656         {
 657             sLog.outError("Item::AddToUpdateQueueOf - GetPlayer didn't find a player matching owner's guid (%u)!", GUID_LOPART(GetOwnerGUID()));
 658             return;
 659         }
 660     }
 661
 662     if (player->GetGUID() != GetOwnerGUID())
 663     {
 664         sLog.outError("Item::AddToUpdateQueueOf - Owner's guid (%u) and player's guid (%u) don't match!", GUID_LOPART(GetOwnerGUID()), player->GetGUIDLow());
 665         return;
 666     }
 667
 668     if (player->m_itemUpdateQueueBlocked) return;
 669
 670     player->m_itemUpdateQueue.push_back(this);
 671     uQueuePos = player->m_itemUpdateQueue.size()-1;
 672 }
 673
 674 void Item::RemoveFromUpdateQueueOf(Player *player)
 675 {
 676     if (!IsInUpdateQueue()) return;
 677
 678     if (!player)
 679     {
 680         player = GetOwner();
 681         if (!player)
 682         {
 683             sLog.outError("Item::RemoveFromUpdateQueueOf - GetPlayer didn't find a player matching owner's guid (%u)!", GUID_LOPART(GetOwnerGUID()));
 684             return;
 685         }
 686     }
 687
 688     if (player->GetGUID() != GetOwnerGUID())
 689     {
 690         sLog.outError("Item::RemoveFromUpdateQueueOf - Owner's guid (%u) and player's guid (%u) don't match!", GUID_LOPART(GetOwnerGUID()), player->GetGUIDLow());
 691         return;
 692     }
 693
 694     if (player->m_itemUpdateQueueBlocked) return;
 695
 696     player->m_itemUpdateQueue[uQueuePos] = NULL;
 697     uQueuePos = -1;
 698 }
 699
 700 uint8 Item::GetBagSlot() const
 701 {
 702     return m_container ? m_container->GetSlot() : uint8(INVENTORY_SLOT_BAG_0);
 703 }
 704
 705 bool Item::IsEquipped() const
 706 {
 707     return !IsInBag() && m_slot < EQUIPMENT_SLOT_END;
 708 }
 709
 710 bool Item::CanBeTraded(bool mail) const
 711 {
 712     if (m_lootGenerated)
 713         return false;
 714
 715     if ((!mail || !IsBoundAccountWide()) && IsSoulBound())
 716         return false;
 717
 718     if (IsBag() && (Player::IsBagPos(GetPos()) || !((Bag const*)this)->IsEmpty()) )
 719         return false;
 720
 721     if (Player* owner = GetOwner())
 722     {
 723         if (owner->CanUnequipItem(GetPos(),false) !=  EQUIP_ERR_OK )
 724             return false;
 725         if (owner->GetLootGUID()==GetGUID())
 726             return false;
 727     }
 728
 729     if (IsBoundByEnchant())
 730         return false;
 731
 732     return true;
 733 }
 734
 735 bool Item::IsBoundByEnchant() const
 736 {
 737     // Check all enchants for soulbound
 738     for(uint32 enchant_slot = PERM_ENCHANTMENT_SLOT; enchant_slot < MAX_ENCHANTMENT_SLOT; ++enchant_slot)
 739     {
 740         uint32 enchant_id = GetEnchantmentId(EnchantmentSlot(enchant_slot));
 741         if(!enchant_id)
 742             continue;
 743
 744         SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
 745         if(!enchantEntry)
 746             continue;
 747
 748         if(enchantEntry->slot & ENCHANTMENT_CAN_SOULBOUND)
 749             return true;
 750     }
 751     return false;
 752 }
 753
 754 bool Item::IsFitToSpellRequirements(SpellEntry const* spellInfo) const
 755 {
 756     ItemPrototype const* proto = GetProto();
 757
 758     if (spellInfo->EquippedItemClass != -1)                 // -1 == any item class
 759     {
 760         if(spellInfo->EquippedItemClass != int32(proto->Class))
 761             return false;                                   //  wrong item class
 762
 763         if(spellInfo->EquippedItemSubClassMask != 0)        // 0 == any subclass
 764         {
 765             if((spellInfo->EquippedItemSubClassMask & (1 << proto->SubClass)) == 0)
 766                 return false;                               // subclass not present in mask
 767         }
 768     }
 769
 770     if(spellInfo->EquippedItemInventoryTypeMask != 0)       // 0 == any inventory type
 771     {
 772         if((spellInfo->EquippedItemInventoryTypeMask  & (1 << proto->InventoryType)) == 0)
 773             return false;                                   // inventory type not present in mask
 774     }
 775
 776     return true;
 777 }
 778
 779 bool Item::IsTargetValidForItemUse(Unit* pUnitTarget)
 780 {
 781     ItemRequiredTargetMapBounds bounds = sObjectMgr.GetItemRequiredTargetMapBounds(GetProto()->ItemId);
 782
 783     if (bounds.first == bounds.second)
 784         return true;
 785
 786     if (!pUnitTarget)
 787         return false;
 788
 789     for(ItemRequiredTargetMap::const_iterator itr = bounds.first; itr != bounds.second; ++itr)
 790         if(itr->second.IsFitToRequirements(pUnitTarget))
 791             return true;
 792
 793     return false;
 794 }
 795
 796 void Item::SetEnchantment(EnchantmentSlot slot, uint32 id, uint32 duration, uint32 charges)
 797 {
 798     // Better lost small time at check in comparison lost time at item save to DB.
 799     if((GetEnchantmentId(slot) == id) && (GetEnchantmentDuration(slot) == duration) && (GetEnchantmentCharges(slot) == charges))
 800         return;
 801
 802     SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot*MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_ID_OFFSET,id);
 803     SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot*MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_DURATION_OFFSET,duration);
 804     SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot*MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_CHARGES_OFFSET,charges);
 805     SetState(ITEM_CHANGED);
 806 }
 807
 808 void Item::SetEnchantmentDuration(EnchantmentSlot slot, uint32 duration)
 809 {
 810     if(GetEnchantmentDuration(slot) == duration)
 811         return;
 812
 813     SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot*MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_DURATION_OFFSET,duration);
 814     SetState(ITEM_CHANGED);
 815 }
 816
 817 void Item::SetEnchantmentCharges(EnchantmentSlot slot, uint32 charges)
 818 {
 819     if(GetEnchantmentCharges(slot) == charges)
 820         return;
 821
 822     SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot*MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_CHARGES_OFFSET,charges);
 823     SetState(ITEM_CHANGED);
 824 }
 825
 826 void Item::ClearEnchantment(EnchantmentSlot slot)
 827 {
 828     if(!GetEnchantmentId(slot))
 829         return;
 830
 831     for(uint8 x = 0; x < 3; ++x)
 832         SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot*MAX_ENCHANTMENT_OFFSET + x, 0);
 833     SetState(ITEM_CHANGED);
 834 }
 835
 836 bool Item::GemsFitSockets() const
 837 {
 838     bool fits = true;
 839     for(uint32 enchant_slot = SOCK_ENCHANTMENT_SLOT; enchant_slot < SOCK_ENCHANTMENT_SLOT+MAX_GEM_SOCKETS; ++enchant_slot)
 840     {
 841         uint8 SocketColor = GetProto()->Socket[enchant_slot-SOCK_ENCHANTMENT_SLOT].Color;
 842
 843         uint32 enchant_id = GetEnchantmentId(EnchantmentSlot(enchant_slot));
 844         if(!enchant_id)
 845         {
 846             if(SocketColor) fits &= false;
 847             continue;
 848         }
 849
 850         SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
 851         if(!enchantEntry)
 852         {
 853             if(SocketColor) fits &= false;
 854             continue;
 855         }
 856
 857         uint8 GemColor = 0;
 858
 859         uint32 gemid = enchantEntry->GemID;
 860         if(gemid)
 861         {
 862             ItemPrototype const* gemProto = sItemStorage.LookupEntry<ItemPrototype>(gemid);
 863             if(gemProto)
 864             {
 865                 GemPropertiesEntry const* gemProperty = sGemPropertiesStore.LookupEntry(gemProto->GemProperties);
 866                 if(gemProperty)
 867                     GemColor = gemProperty->color;
 868             }
 869         }
 870
 871         fits &= (GemColor & SocketColor) ? true : false;
 872     }
 873     return fits;
 874 }
 875
 876 uint8 Item::GetGemCountWithID(uint32 GemID) const
 877 {
 878     uint8 count = 0;
 879     for(uint32 enchant_slot = SOCK_ENCHANTMENT_SLOT; enchant_slot < SOCK_ENCHANTMENT_SLOT+MAX_GEM_SOCKETS; ++enchant_slot)
 880     {
 881         uint32 enchant_id = GetEnchantmentId(EnchantmentSlot(enchant_slot));
 882         if(!enchant_id)
 883             continue;
 884
 885         SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
 886         if(!enchantEntry)
 887             continue;
 888
 889         if(GemID == enchantEntry->GemID)
 890             ++count;
 891     }
 892     return count;
 893 }
 894
 895 uint8 Item::GetGemCountWithLimitCategory(uint32 limitCategory) const
 896 {
 897     uint8 count = 0;
 898     for(uint32 enchant_slot = SOCK_ENCHANTMENT_SLOT; enchant_slot < SOCK_ENCHANTMENT_SLOT+MAX_GEM_SOCKETS; ++enchant_slot)
 899     {
 900         uint32 enchant_id = GetEnchantmentId(EnchantmentSlot(enchant_slot));
 901         if(!enchant_id)
 902             continue;
 903
 904         SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
 905         if(!enchantEntry)
 906             continue;
 907
 908         ItemPrototype const* gemProto = ObjectMgr::GetItemPrototype(enchantEntry->GemID);
 909         if(!gemProto)
 910             continue;
 911
 912         if(gemProto->ItemLimitCategory==limitCategory)
 913             ++count;
 914     }
 915     return count;
 916 }
 917
 918 bool Item::IsLimitedToAnotherMapOrZone( uint32 cur_mapId, uint32 cur_zoneId) const
 919 {
 920     ItemPrototype const* proto = GetProto();
 921     return proto && (proto->Map && proto->Map != cur_mapId || proto->Area && proto->Area != cur_zoneId );
 922 }
 923
 924 // Though the client has the information in the item's data field,
 925 // we have to send SMSG_ITEM_TIME_UPDATE to display the remaining
 926 // time.
 927 void Item::SendTimeUpdate(Player* owner)
 928 {
 929     if (!GetUInt32Value(ITEM_FIELD_DURATION))
 930         return;
 931
 932     WorldPacket data(SMSG_ITEM_TIME_UPDATE, (8+4));
 933     data << (uint64)GetGUID();
 934     data << (uint32)GetUInt32Value(ITEM_FIELD_DURATION);
 935     owner->GetSession()->SendPacket(&data);
 936 }
 937
 938 Item* Item::CreateItem( uint32 item, uint32 count, Player const* player )
 939 {
 940     if ( count < 1 )
 941         return NULL;                                        //don't create item at zero count
 942
 943     ItemPrototype const *pProto = ObjectMgr::GetItemPrototype( item );
 944     if( pProto )
 945     {
 946         if ( count > pProto->GetMaxStackSize())
 947             count = pProto->GetMaxStackSize();
 948
 949         assert(count !=0 && "pProto->Stackable==0 but checked at loading already");
 950
 951         Item *pItem = NewItemOrBag( pProto );
 952         if( pItem->Create(sObjectMgr.GenerateLowGuid(HIGHGUID_ITEM), item, player) )
 953         {
 954             pItem->SetCount( count );
 955             return pItem;
 956         }
 957         else
 958             delete pItem;
 959     }
 960     return NULL;
 961 }
 962
 963 Item* Item::CloneItem( uint32 count, Player const* player ) const
 964 {
 965     Item* newItem = CreateItem( GetEntry(), count, player );
 966     if(!newItem)
 967         return NULL;
 968
 969     newItem->SetUInt32Value( ITEM_FIELD_CREATOR,      GetUInt32Value( ITEM_FIELD_CREATOR ) );
 970     newItem->SetUInt32Value( ITEM_FIELD_GIFTCREATOR,  GetUInt32Value( ITEM_FIELD_GIFTCREATOR ) );
 971     newItem->SetUInt32Value( ITEM_FIELD_FLAGS,        GetUInt32Value( ITEM_FIELD_FLAGS ) );
 972     newItem->SetUInt32Value( ITEM_FIELD_DURATION,     GetUInt32Value( ITEM_FIELD_DURATION ) );
 973     newItem->SetItemRandomProperties(GetItemRandomPropertyId());
 974     return newItem;
 975 }
 976
 977 bool Item::IsBindedNotWith( Player const* player ) const
 978 {
 979     // not binded item
 980     if(!IsSoulBound())
 981         return false;
 982
 983     // own item
 984     if(GetOwnerGUID()== player->GetGUID())
 985         return false;
 986
 987     // not BOA item case
 988     if(!IsBoundAccountWide())
 989         return true;
 990
 991     // online
 992     if(Player* owner = sObjectMgr.GetPlayer(GetOwnerGUID()))
 993     {
 994         return owner->GetSession()->GetAccountId() != player->GetSession()->GetAccountId();
 995     }
 996     // offline slow case
 997     else
 998     {
 999         return sObjectMgr.GetPlayerAccountIdByGUID(GetOwnerGUID()) != player->GetSession()->GetAccountId();
1000     }
1001 }
1002
1003 void Item::AddToClientUpdateList()
1004 {
1005     if (Player* pl = GetOwner())
1006         pl->GetMap()->AddUpdateObject(this);
1007 }
1008
1009 void Item::RemoveFromClientUpdateList()
1010 {
1011     if (Player* pl = GetOwner())
1012         pl->GetMap()->RemoveUpdateObject(this);
1013 }
1014
1015 void Item::BuildUpdateData(UpdateDataMapType& update_players)
1016 {
1017     if (Player* pl = GetOwner())
1018         BuildUpdateDataForPlayer(pl, update_players);
1019
1020     ClearUpdateMask(false);
1021 }
1022
1023 uint8 Item::CanBeMergedPartlyWith( ItemPrototype const* proto ) const
1024 {
1025     // check item type
1026     if (GetEntry() != proto->ItemId)
1027         return EQUIP_ERR_ITEM_CANT_STACK;
1028
1029     // check free space (full stacks can't be target of merge
1030     if (GetCount() >= proto->GetMaxStackSize())
1031         return EQUIP_ERR_ITEM_CANT_STACK;
1032
1033     // not allow merge looting currently items
1034     if (m_lootGenerated)
1035         return EQUIP_ERR_ALREADY_LOOTED;
1036
1037     return EQUIP_ERR_OK;
1038 }
1039
1040 bool ItemRequiredTarget::IsFitToRequirements( Unit* pUnitTarget ) const
1041 {
1042     if(pUnitTarget->GetTypeId() != TYPEID_UNIT)
1043         return false;
1044
1045     if(pUnitTarget->GetEntry() != m_uiTargetEntry)
1046         return false;
1047
1048     switch(m_uiType)
1049     {
1050         case ITEM_TARGET_TYPE_CREATURE:
1051             return pUnitTarget->isAlive();
1052         case ITEM_TARGET_TYPE_DEAD:
1053             return !pUnitTarget->isAlive();
1054         default:
1055             return false;
1056     }
1057 }
1058
1059 bool Item::HasMaxCharges() const
1060 {
1061     ItemPrototype const* itemProto = GetProto();
1062
1063     for(int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
1064         if (GetSpellCharges(i) != itemProto->Spells[i].SpellCharges)
1065             return false;
1066
1067     return true;
1068 }
1069
1070 void Item::RestoreCharges()
1071 {
1072     ItemPrototype const* itemProto = GetProto();
1073
1074     for(int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
1075     {
1076         if (GetSpellCharges(i) != itemProto->Spells[i].SpellCharges)
1077         {
1078             SetSpellCharges(i, itemProto->Spells[i].SpellCharges);
1079             SetState(ITEM_CHANGED);
1080         }
1081     }
1082 }