Item.h

Go to the documentation of this file.

 
// Item.h
 
// Declares the cItem class representing an item (in the inventory sense)
 
 
 
 
 
#pragma once
 
#include "Defines.h"
#include "Enchantments.h"
#include "WorldStorage/FireworksSerializer.h"
#include "Color.h"
 
 
 
 
 
// fwd:
class cItemHandler;
class cItemGrid;
class cColor;
 
namespace Json
{
    class Value;
}
 
 
 
 
 
// tolua_begin
class cItem
{
public:
    cItem(void);
 
    cItem(
        short a_ItemType,
        char a_ItemCount = 1,
        short a_ItemDamage = 0,
        const AString & a_Enchantments = "",
        const AString & a_CustomName = "",
        const AStringVector & a_LoreTable = {}
    );
 
    // The constructor is disabled in code, because the compiler generates it anyway,
    // but it needs to stay because ToLua needs to generate the binding for it
    #ifdef TOLUA_EXPOSITION
 
    cItem(const cItem & a_CopyFrom);
 
    #endif
 
    void Empty(void);
 
    void Clear(void);
 
    bool IsEmpty(void) const
    {
        return ((m_ItemType <= 0) || (m_ItemCount <= 0));
    }
 
    /* Returns true if this itemstack can stack with the specified stack (types match, enchantments etc.)
    ItemCounts are ignored. */
    bool IsEqual(const cItem & a_Item) const
    {
        return (
            IsSameType(a_Item) &&
            (m_ItemDamage == a_Item.m_ItemDamage) &&
            (m_Enchantments == a_Item.m_Enchantments) &&
            (m_CustomName == a_Item.m_CustomName) &&
            (m_LoreTable == a_Item.m_LoreTable) &&
            m_FireworkItem.IsEqualTo(a_Item.m_FireworkItem)
        );
    }
 
 
    bool IsSameType(const cItem & a_Item) const
    {
        return (m_ItemType == a_Item.m_ItemType) || (IsEmpty() && a_Item.IsEmpty());
    }
 
 
    bool IsBothNameAndLoreEmpty(void) const
    {
        return (m_CustomName.empty() && m_LoreTable.empty());
    }
 
 
    bool IsCustomNameEmpty(void) const { return (m_CustomName.empty()); }
    bool IsLoreEmpty(void) const { return (m_LoreTable.empty()); }
 
    cItem CopyOne(void) const;
 
    cItem & AddCount(char a_AmountToAdd);
 
    short GetMaxDamage(void) const;
 
    bool DamageItem(short a_Amount = 1);
 
    inline bool IsDamageable(void) const { return (GetMaxDamage() > 0); }
 
    bool IsFullStack(void) const;
 
    char GetMaxStackSize(void) const;
 
    // tolua_end
 
    const cItemHandler & GetHandler(void) const;
 
    void GetJson(Json::Value & a_OutValue) const;
 
    void FromJson(const Json::Value & a_Value);
 
    static bool IsEnchantable(short a_ItemType, bool a_FromBook = false);  // tolua_export
 
    unsigned GetEnchantability();  // tolua_export
 
    bool EnchantByXPLevels(unsigned a_NumXPLevels, MTRand & a_Random);  // Exported in ManualBindings.cpp
 
    int AddEnchantment(int a_EnchantmentID, unsigned int a_Level, bool a_FromBook);  // tolua_export
 
    int AddEnchantmentsFromItem(const cItem & a_Other);  // tolua_export
 
    bool CanHaveEnchantment(int a_EnchantmentID);
 
    // tolua_begin
 
    short          m_ItemType;
    char           m_ItemCount;
    short          m_ItemDamage;
    cEnchantments  m_Enchantments;
    AString        m_CustomName;
 
    // tolua_end
 
    AStringVector  m_LoreTable;  // Exported in ManualBindings.cpp
 
    struct sItemCompare
    {
        bool operator() (const cItem & a_Lhs, const cItem & a_Rhs) const
        {
            if (a_Lhs.m_ItemType != a_Rhs.m_ItemType)
            {
                return (a_Lhs.m_ItemType < a_Rhs.m_ItemType);
            }
            if ((a_Lhs.m_ItemDamage == -1) || (a_Rhs.m_ItemDamage == -1))
            {
                return false;  // -1 is a wildcard, damage of -1 alway compares equal
            }
            return (a_Lhs.m_ItemDamage < a_Rhs.m_ItemDamage);
        }
    };
 
    // tolua_begin
 
    int            m_RepairCost;
    cFireworkItem  m_FireworkItem;
    cColor         m_ItemColor;
};
// tolua_end
 
 
 
 
 
class cItems  // tolua_export
    : public std::vector<cItem>
{  // tolua_export
public:
 
    cItems(const cItems &) = default;
    cItems(cItems &&) = default;
    cItems & operator = (const cItems &) = default;
    cItems & operator = (cItems &&) = default;
 
    cItems(cItem && a_InitialItem);
 
    // tolua_begin
 
    cItems(void) {}
 
    cItem * Get   (int a_Idx);
    void    Set   (int a_Idx, const cItem & a_Item);
    void    Add   (const cItem & a_Item) {push_back(a_Item); }
    void    Add   (short a_ItemType) { emplace_back(a_ItemType); }
    void    Add   (short a_ItemType, char a_ItemCount) { emplace_back(a_ItemType, a_ItemCount); }
    void    Delete(int a_Idx);
    void    Clear (void) {clear(); }
    size_t  Size  (void) const { return size(); }
    void    Set   (int a_Idx, short a_ItemType, char a_ItemCount, short a_ItemDamage);
    bool    Contains(const cItem & a_Item);
    bool    ContainsType(const cItem & a_Item);
 
    void    Add   (short a_ItemType, char a_ItemCount, short a_ItemDamage)
    {
        emplace_back(a_ItemType, a_ItemCount, a_ItemDamage);
    }
 
    void AddItemGrid(const cItemGrid & a_ItemGrid);
 
    // tolua_end
} ;  // tolua_export
 
 
 
 
 
class cLootProbab
{
public:
    cItem m_Item;
    int   m_MinAmount;
    int   m_MaxAmount;
    int   m_Weight;
} ;