src/game/LootMgr.h

   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 #ifndef MANGOS_LOOTMGR_H
  20 #define MANGOS_LOOTMGR_H
  21
  22 #include "ItemEnchantmentMgr.h"
  23 #include "ByteBuffer.h"
  24 #include "Utilities/LinkedReference/RefManager.h"
  25
  26 #include <map>
  27 #include <vector>
  28
  29 #define MAX_NR_LOOT_ITEMS 16
  30 // note: the client cannot show more than 16 items total
  31 #define MAX_NR_QUEST_ITEMS 32
  32 // unrelated to the number of quest items shown, just for reserve
  33
  34 enum PermissionTypes
  35 {
  36     ALL_PERMISSION    = 0,
  37     GROUP_PERMISSION  = 1,
  38     MASTER_PERMISSION = 2,
  39     NONE_PERMISSION   = 3
  40 };
  41
  42 enum LootType
  43 {
  44     LOOT_CORPSE                 = 1,
  45     LOOT_PICKPOCKETING          = 2,
  46     LOOT_FISHING                = 3,
  47     LOOT_DISENCHANTING          = 4,
  48                                                             // ignored always by client
  49     LOOT_SKINNING               = 6,
  50     LOOT_PROSPECTING            = 7,
  51     LOOT_MILLING                = 8,
  52
  53     LOOT_FISHINGHOLE            = 20,                       // unsupported by client, sending LOOT_FISHING instead
  54     LOOT_INSIGNIA               = 21                        // unsupported by client, sending LOOT_CORPSE instead
  55 };
  56
  57 class Player;
  58 class LootStore;
  59
  60 struct LootStoreItem
  61 {
  62     uint32  itemid;                                         // id of the item
  63     float   chance;                                         // always positive, chance to drop for both quest and non-quest items, chance to be used for refs
  64     int32   mincountOrRef;                                  // mincount for drop items (positive) or minus referenced TemplateleId (negative)
  65     uint8   group       :7;
  66     bool    needs_quest :1;                                 // quest drop (negative ChanceOrQuestChance in DB)
  67     uint8   maxcount    :8;                                 // max drop count for the item (mincountOrRef positive) or Ref multiplicator (mincountOrRef negative)
  68     uint16  conditionId :16;                                // additional loot condition Id
  69
  70     // Constructor, converting ChanceOrQuestChance -> (chance, needs_quest)
  71     // displayid is filled in IsValid() which must be called after
  72     LootStoreItem(uint32 _itemid, float _chanceOrQuestChance, int8 _group, uint16 _conditionId, int32 _mincountOrRef, uint8 _maxcount)
  73         : itemid(_itemid), chance(fabs(_chanceOrQuestChance)), mincountOrRef(_mincountOrRef),
  74         group(_group), needs_quest(_chanceOrQuestChance < 0), maxcount(_maxcount), conditionId(_conditionId)
  75          {}
  76
  77     bool Roll(bool rate) const;                             // Checks if the entry takes it's chance (at loot generation)
  78     bool IsValid(LootStore const& store, uint32 entry) const;
  79                                                             // Checks correctness of values
  80 };
  81
  82 struct LootItem
  83 {
  84     uint32  itemid;
  85     uint32  randomSuffix;
  86     int32   randomPropertyId;
  87     uint16  conditionId       :16;                          // allow compiler pack structure
  88     uint8   count             : 8;
  89     bool    is_looted         : 1;
  90     bool    is_blocked        : 1;
  91     bool    freeforall        : 1;                          // free for all
  92     bool    is_underthreshold : 1;
  93     bool    is_counted        : 1;
  94     bool    needs_quest       : 1;                          // quest drop
  95
  96     // Constructor, copies most fields from LootStoreItem, generates random count and random suffixes/properties
  97     // Should be called for non-reference LootStoreItem entries only (mincountOrRef > 0)
  98     explicit LootItem(LootStoreItem const& li);
  99
 100     // Basic checks for player/item compatibility - if false no chance to see the item in the loot
 101     bool AllowedForPlayer(Player const * player) const;
 102 };
 103
 104 typedef std::vector<LootItem> LootItemList;
 105
 106 struct QuestItem
 107 {
 108     uint8   index;                                          // position in quest_items;
 109     bool    is_looted;
 110
 111     QuestItem()
 112         : index(0), is_looted(false) {}
 113
 114     QuestItem(uint8 _index, bool _islooted = false)
 115         : index(_index), is_looted(_islooted) {}
 116 };
 117
 118 struct Loot;
 119 class LootTemplate;
 120
 121 typedef std::vector<QuestItem> QuestItemList;
 122 typedef std::map<uint32, QuestItemList *> QuestItemMap;
 123 typedef std::vector<LootStoreItem> LootStoreItemList;
 124 typedef UNORDERED_MAP<uint32, LootTemplate*> LootTemplateMap;
 125
 126 typedef std::set<uint32> LootIdSet;
 127
 128 class LootStore
 129 {
 130     public:
 131         explicit LootStore(char const* name, char const* entryName, bool ratesAllowed)
 132             : m_name(name), m_entryName(entryName), m_ratesAllowed(ratesAllowed) {}
 133         virtual ~LootStore() { Clear(); }
 134
 135         void Verify() const;
 136
 137         void LoadAndCollectLootIds(LootIdSet& ids_set);
 138         void CheckLootRefs(LootIdSet* ref_set = NULL) const;// check existence reference and remove it from ref_set
 139         void ReportUnusedIds(LootIdSet const& ids_set) const;
 140         void ReportNotExistedId(uint32 id) const;
 141
 142         bool HaveLootFor(uint32 loot_id) const { return m_LootTemplates.find(loot_id) != m_LootTemplates.end(); }
 143         bool HaveQuestLootFor(uint32 loot_id) const;
 144         bool HaveQuestLootForPlayer(uint32 loot_id,Player* player) const;
 145
 146         LootTemplate const* GetLootFor(uint32 loot_id) const;
 147
 148         char const* GetName() const { return m_name; }
 149         char const* GetEntryName() const { return m_entryName; }
 150         bool IsRatesAllowed() const { return m_ratesAllowed; }
 151     protected:
 152         void LoadLootTable();
 153         void Clear();
 154     private:
 155         LootTemplateMap m_LootTemplates;
 156         char const* m_name;
 157         char const* m_entryName;
 158         bool m_ratesAllowed;
 159 };
 160
 161 class LootTemplate
 162 {
 163     class  LootGroup;                                       // A set of loot definitions for items (refs are not allowed inside)
 164     typedef std::vector<LootGroup> LootGroups;
 165
 166     public:
 167         // Adds an entry to the group (at loading stage)
 168         void AddEntry(LootStoreItem& item);
 169         // Rolls for every item in the template and adds the rolled items the the loot
 170         void Process(Loot& loot, LootStore const& store, bool rate, uint8 GroupId = 0) const;
 171
 172         // True if template includes at least 1 quest drop entry
 173         bool HasQuestDrop(LootTemplateMap const& store, uint8 GroupId = 0) const;
 174         // True if template includes at least 1 quest drop for an active quest of the player
 175         bool HasQuestDropForPlayer(LootTemplateMap const& store, Player const * player, uint8 GroupId = 0) const;
 176
 177         // Checks integrity of the template
 178         void Verify(LootStore const& store, uint32 Id) const;
 179         void CheckLootRefs(LootIdSet* ref_set) const;
 180     private:
 181         LootStoreItemList Entries;                          // not grouped only
 182         LootGroups        Groups;                           // groups have own (optimised) processing, grouped entries go there
 183 };
 184
 185 //=====================================================
 186
 187 class LootValidatorRef :  public Reference<Loot, LootValidatorRef>
 188 {
 189     public:
 190         LootValidatorRef() {}
 191         void targetObjectDestroyLink() {}
 192         void sourceObjectDestroyLink() {}
 193 };
 194
 195 //=====================================================
 196
 197 class LootValidatorRefManager : public RefManager<Loot, LootValidatorRef>
 198 {
 199     public:
 200         typedef LinkedListHead::Iterator< LootValidatorRef > iterator;
 201
 202         LootValidatorRef* getFirst() { return (LootValidatorRef*)RefManager<Loot, LootValidatorRef>::getFirst(); }
 203         LootValidatorRef* getLast() { return (LootValidatorRef*)RefManager<Loot, LootValidatorRef>::getLast(); }
 204
 205         iterator begin() { return iterator(getFirst()); }
 206         iterator end() { return iterator(NULL); }
 207         iterator rbegin() { return iterator(getLast()); }
 208         iterator rend() { return iterator(NULL); }
 209 };
 210
 211 //=====================================================
 212 struct LootView;
 213
 214 ByteBuffer& operator<<(ByteBuffer& b, LootItem const& li);
 215 ByteBuffer& operator<<(ByteBuffer& b, LootView const& lv);
 216
 217 struct Loot
 218 {
 219     friend ByteBuffer& operator<<(ByteBuffer& b, LootView const& lv);
 220
 221     QuestItemMap const& GetPlayerQuestItems() const { return PlayerQuestItems; }
 222     QuestItemMap const& GetPlayerFFAItems() const { return PlayerFFAItems; }
 223     QuestItemMap const& GetPlayerNonQuestNonFFAConditionalItems() const { return PlayerNonQuestNonFFAConditionalItems; }
 224
 225     LootItemList items;
 226     uint32 gold;
 227     uint8 unlootedCount;
 228     LootType loot_type;                                     // required for achievement system
 229
 230     Loot(uint32 _gold = 0) : gold(_gold), unlootedCount(0), loot_type(LOOT_CORPSE) {}
 231     ~Loot() { clear(); }
 232
 233     // if loot becomes invalid this reference is used to inform the listener
 234     void addLootValidatorRef(LootValidatorRef* pLootValidatorRef)
 235     {
 236         i_LootValidatorRefManager.insertFirst(pLootValidatorRef);
 237     }
 238
 239     // void clear();
 240     void clear()
 241     {
 242         for (QuestItemMap::const_iterator itr = PlayerQuestItems.begin(); itr != PlayerQuestItems.end(); ++itr)
 243             delete itr->second;
 244         PlayerQuestItems.clear();
 245
 246         for (QuestItemMap::const_iterator itr = PlayerFFAItems.begin(); itr != PlayerFFAItems.end(); ++itr)
 247             delete itr->second;
 248         PlayerFFAItems.clear();
 249
 250         for (QuestItemMap::const_iterator itr = PlayerNonQuestNonFFAConditionalItems.begin(); itr != PlayerNonQuestNonFFAConditionalItems.end(); ++itr)
 251             delete itr->second;
 252         PlayerNonQuestNonFFAConditionalItems.clear();
 253
 254         PlayersLooting.clear();
 255         items.clear();
 256         quest_items.clear();
 257         gold = 0;
 258         unlootedCount = 0;
 259         i_LootValidatorRefManager.clearReferences();
 260     }
 261
 262     bool empty() const { return items.empty() && gold == 0; }
 263     bool isLooted() const { return gold == 0 && unlootedCount == 0; }
 264
 265     void NotifyItemRemoved(uint8 lootIndex);
 266     void NotifyQuestItemRemoved(uint8 questIndex);
 267     void NotifyMoneyRemoved();
 268     void AddLooter(uint64 GUID) { PlayersLooting.insert(GUID); }
 269     void RemoveLooter(uint64 GUID) { PlayersLooting.erase(GUID); }
 270
 271     void generateMoneyLoot(uint32 minAmount, uint32 maxAmount);
 272     bool FillLoot(uint32 loot_id, LootStore const& store, Player* loot_owner, bool personal, bool noEmptyError = false);
 273
 274     // Inserts the item into the loot (called by LootTemplate processors)
 275     void AddItem(LootStoreItem const & item);
 276
 277     LootItem* LootItemInSlot(uint32 lootslot, Player* player, QuestItem** qitem = NULL, QuestItem** ffaitem = NULL, QuestItem** conditem = NULL);
 278     uint32 GetMaxSlotInLootFor(Player* player) const;
 279
 280     private:
 281         void FillNotNormalLootFor(Player* player);
 282         QuestItemList* FillFFALoot(Player* player);
 283         QuestItemList* FillQuestLoot(Player* player);
 284         QuestItemList* FillNonQuestNonFFAConditionalLoot(Player* player);
 285
 286         LootItemList quest_items;
 287         std::set<uint64> PlayersLooting;
 288         QuestItemMap PlayerQuestItems;
 289         QuestItemMap PlayerFFAItems;
 290         QuestItemMap PlayerNonQuestNonFFAConditionalItems;
 291
 292         // All rolls are registered here. They need to know, when the loot is not valid anymore
 293         LootValidatorRefManager i_LootValidatorRefManager;
 294 };
 295
 296 struct LootView
 297 {
 298     Loot &loot;
 299     Player *viewer;
 300     PermissionTypes permission;
 301     LootView(Loot &_loot, Player *_viewer,PermissionTypes _permission = ALL_PERMISSION)
 302         : loot(_loot), viewer(_viewer), permission(_permission) {}
 303 };
 304
 305 extern LootStore LootTemplates_Creature;
 306 extern LootStore LootTemplates_Fishing;
 307 extern LootStore LootTemplates_Gameobject;
 308 extern LootStore LootTemplates_Item;
 309 extern LootStore LootTemplates_Mail;
 310 extern LootStore LootTemplates_Milling;
 311 extern LootStore LootTemplates_Pickpocketing;
 312 extern LootStore LootTemplates_Skinning;
 313 extern LootStore LootTemplates_Disenchant;
 314 extern LootStore LootTemplates_Prospecting;
 315 extern LootStore LootTemplates_Spell;
 316
 317 void LoadLootTemplates_Creature();
 318 void LoadLootTemplates_Fishing();
 319 void LoadLootTemplates_Gameobject();
 320 void LoadLootTemplates_Item();
 321 void LoadLootTemplates_Mail();
 322 void LoadLootTemplates_Milling();
 323 void LoadLootTemplates_Pickpocketing();
 324 void LoadLootTemplates_Skinning();
 325 void LoadLootTemplates_Disenchant();
 326 void LoadLootTemplates_Prospecting();
 327
 328 void LoadLootTemplates_Spell();
 329 void LoadLootTemplates_Reference();
 330
 331 inline void LoadLootTables()
 332 {
 333     LoadLootTemplates_Creature();
 334     LoadLootTemplates_Fishing();
 335     LoadLootTemplates_Gameobject();
 336     LoadLootTemplates_Item();
 337     LoadLootTemplates_Mail();
 338     LoadLootTemplates_Milling();
 339     LoadLootTemplates_Pickpocketing();
 340     LoadLootTemplates_Skinning();
 341     LoadLootTemplates_Disenchant();
 342     LoadLootTemplates_Prospecting();
 343     LoadLootTemplates_Spell();
 344
 345     LoadLootTemplates_Reference();
 346 }
 347
 348 #endif