src/game/Bag.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 "Bag.h"
  21 #include "ObjectMgr.h"
  22 #include "Database/DatabaseEnv.h"
  23 #include "Log.h"
  24 #include "UpdateData.h"
  25
  26 Bag::Bag( ): Item()
  27 {
  28     m_objectType |= TYPEMASK_CONTAINER;
  29     m_objectTypeId = TYPEID_CONTAINER;
  30
  31     m_valuesCount = CONTAINER_END;
  32
  33     memset(m_bagslot, 0, sizeof(Item *) * MAX_BAG_SIZE);
  34 }
  35
  36 Bag::~Bag()
  37 {
  38     for(int i = 0; i < MAX_BAG_SIZE; ++i)
  39         if (m_bagslot[i])
  40             delete m_bagslot[i];
  41 }
  42
  43 void Bag::AddToWorld()
  44 {
  45     Item::AddToWorld();
  46
  47     for(uint32 i = 0;  i < GetBagSize(); ++i)
  48         if(m_bagslot[i])
  49             m_bagslot[i]->AddToWorld();
  50 }
  51
  52 void Bag::RemoveFromWorld()
  53 {
  54     for(uint32 i = 0; i < GetBagSize(); ++i)
  55         if(m_bagslot[i])
  56             m_bagslot[i]->RemoveFromWorld();
  57
  58     Item::RemoveFromWorld();
  59 }
  60
  61 bool Bag::Create(uint32 guidlow, uint32 itemid, Player const* owner)
  62 {
  63     ItemPrototype const * itemProto = ObjectMgr::GetItemPrototype(itemid);
  64
  65     if(!itemProto || itemProto->ContainerSlots > MAX_BAG_SIZE)
  66         return false;
  67
  68     Object::_Create( guidlow, 0, HIGHGUID_CONTAINER );
  69
  70     SetEntry(itemid);
  71     SetFloatValue(OBJECT_FIELD_SCALE_X, 1.0f);
  72
  73     SetUInt64Value(ITEM_FIELD_OWNER, owner ? owner->GetGUID() : 0);
  74     SetUInt64Value(ITEM_FIELD_CONTAINED, owner ? owner->GetGUID() : 0);
  75
  76     SetUInt32Value(ITEM_FIELD_MAXDURABILITY, itemProto->MaxDurability);
  77     SetUInt32Value(ITEM_FIELD_DURABILITY, itemProto->MaxDurability);
  78     SetUInt32Value(ITEM_FIELD_FLAGS, itemProto->Flags);
  79     SetUInt32Value(ITEM_FIELD_STACK_COUNT, 1);
  80
  81     // Setting the number of Slots the Container has
  82     SetUInt32Value(CONTAINER_FIELD_NUM_SLOTS, itemProto->ContainerSlots);
  83
  84     // Cleaning 20 slots
  85     for (uint8 i = 0; i < MAX_BAG_SIZE; ++i)
  86     {
  87         SetUInt64Value(CONTAINER_FIELD_SLOT_1 + (i*2), 0);
  88         m_bagslot[i] = NULL;
  89     }
  90
  91     return true;
  92 }
  93
  94 void Bag::SaveToDB()
  95 {
  96     Item::SaveToDB();
  97 }
  98
  99 bool Bag::LoadFromDB(uint32 guid, uint64 owner_guid, QueryResult *result)
 100 {
 101     if(!Item::LoadFromDB(guid, owner_guid, result))
 102         return false;
 103
 104     // cleanup bag content related item value fields (its will be filled correctly from `character_inventory`)
 105     for (int i = 0; i < MAX_BAG_SIZE; ++i)
 106     {
 107         SetUInt64Value(CONTAINER_FIELD_SLOT_1 + (i*2), 0);
 108         if (m_bagslot[i])
 109         {
 110             delete m_bagslot[i];
 111             m_bagslot[i] = NULL;
 112         }
 113     }
 114
 115     return true;
 116 }
 117
 118 void Bag::DeleteFromDB()
 119 {
 120     for (int i = 0; i < MAX_BAG_SIZE; ++i)
 121         if (m_bagslot[i])
 122             m_bagslot[i]->DeleteFromDB();
 123
 124     Item::DeleteFromDB();
 125 }
 126
 127 uint32 Bag::GetFreeSlots() const
 128 {
 129     uint32 slots = 0;
 130     for (uint32 i=0; i < GetBagSize(); ++i)
 131         if (!m_bagslot[i])
 132             ++slots;
 133
 134     return slots;
 135 }
 136
 137 void Bag::RemoveItem( uint8 slot, bool /*update*/ )
 138 {
 139     assert(slot < MAX_BAG_SIZE);
 140
 141     if (m_bagslot[slot])
 142         m_bagslot[slot]->SetContainer(NULL);
 143
 144     m_bagslot[slot] = NULL;
 145     SetUInt64Value( CONTAINER_FIELD_SLOT_1 + (slot * 2), 0 );
 146 }
 147
 148 void Bag::StoreItem( uint8 slot, Item *pItem, bool /*update*/ )
 149 {
 150     assert(slot < MAX_BAG_SIZE);
 151
 152     if( pItem )
 153     {
 154         m_bagslot[slot] = pItem;
 155         SetUInt64Value(CONTAINER_FIELD_SLOT_1 + (slot * 2), pItem->GetGUID());
 156         pItem->SetUInt64Value(ITEM_FIELD_CONTAINED, GetGUID());
 157         pItem->SetUInt64Value( ITEM_FIELD_OWNER, GetOwnerGUID() );
 158         pItem->SetContainer(this);
 159         pItem->SetSlot(slot);
 160     }
 161 }
 162
 163 void Bag::BuildCreateUpdateBlockForPlayer( UpdateData *data, Player *target ) const
 164 {
 165     Item::BuildCreateUpdateBlockForPlayer( data, target );
 166
 167     for (uint32 i = 0; i < GetBagSize(); ++i)
 168         if(m_bagslot[i])
 169             m_bagslot[i]->BuildCreateUpdateBlockForPlayer( data, target );
 170 }
 171
 172 // If the bag is empty returns true
 173 bool Bag::IsEmpty() const
 174 {
 175     for(uint32 i = 0; i < GetBagSize(); ++i)
 176         if (m_bagslot[i])
 177             return false;
 178
 179     return true;
 180 }
 181
 182 Item* Bag::GetItemByEntry( uint32 item ) const
 183 {
 184     for(uint32 i = 0; i < GetBagSize(); ++i)
 185         if (m_bagslot[i] && m_bagslot[i]->GetEntry() == item)
 186             return m_bagslot[i];
 187
 188     return NULL;
 189 }
 190
 191 Item* Bag::GetItemByLimitedCategory(uint32 limitedCategory) const
 192 {
 193     for(uint32 i = 0; i < GetBagSize(); ++i)
 194         if (m_bagslot[i] && m_bagslot[i]->GetProto()->ItemLimitCategory == limitedCategory)
 195             return m_bagslot[i];
 196
 197     return NULL;
 198 }
 199
 200 uint32 Bag::GetItemCount( uint32 item, Item* eItem ) const
 201 {
 202     Item *pItem;
 203     uint32 count = 0;
 204     for(uint32 i=0; i < GetBagSize(); ++i)
 205     {
 206         pItem = m_bagslot[i];
 207         if( pItem && pItem != eItem && pItem->GetEntry() == item )
 208             count += pItem->GetCount();
 209     }
 210
 211     if(eItem && eItem->GetProto()->GemProperties)
 212     {
 213         for(uint32 i=0; i < GetBagSize(); ++i)
 214         {
 215             pItem = m_bagslot[i];
 216             if( pItem && pItem != eItem && pItem->GetProto()->Socket[0].Color )
 217                 count += pItem->GetGemCountWithID(item);
 218         }
 219     }
 220
 221     return count;
 222 }
 223
 224 uint32 Bag::GetItemCountWithLimitCategory(uint32 limitCategory) const
 225 {
 226     uint32 count = 0;
 227     for(uint32 i = 0; i < GetBagSize(); ++i)
 228         if (m_bagslot[i])
 229             if (m_bagslot[i]->GetProto()->ItemLimitCategory == limitCategory )
 230                 count += m_bagslot[i]->GetCount();
 231
 232     return count;
 233 }
 234
 235 uint8 Bag::GetSlotByItemGUID(uint64 guid) const
 236 {
 237     for(uint32 i = 0; i < GetBagSize(); ++i)
 238         if(m_bagslot[i] != 0)
 239             if(m_bagslot[i]->GetGUID() == guid)
 240                 return i;
 241
 242     return NULL_SLOT;
 243 }
 244
 245 Item* Bag::GetItemByPos( uint8 slot ) const
 246 {
 247     if( slot < GetBagSize() )
 248         return m_bagslot[slot];
 249
 250     return NULL;
 251 }