Don't include client/game.h on server build

[dragonfireclient.git] / src / inventory.h

diff --git a/src/inventory.h b/src/inventory.h
index 459228d3e328f2cb03b2eb73666d339195c2d64a..8b31de3a8ae39ee563764fd09991e89ef11fad51 100644 (file)
--- a/src/inventory.h
+++ b/src/inventory.h
@@ -32,20 +32,24 @@ struct ToolCapabilities;
 
 struct ItemStack
 {
-       ItemStack() {}
+       ItemStack() = default;
+
        ItemStack(const std::string &name_, u16 count_,
                        u16 wear, IItemDefManager *itemdef);
 
-       ~ItemStack() {}
+       ~ItemStack() = default;
 
        // Serialization
-       void serialize(std::ostream &os) const;
-       // Deserialization.  Pass itemdef unless you don't want aliases resolved.
+       void serialize(std::ostream &os, bool serialize_meta = true) const;
+       // Deserialization. Pass itemdef unless you don't want aliases resolved.
        void deSerialize(std::istream &is, IItemDefManager *itemdef = NULL);
        void deSerialize(const std::string &s, IItemDefManager *itemdef = NULL);
 
        // Returns the string used for inventory
-       std::string getItemString() const;
+       std::string getItemString(bool include_meta = true) const;
+       // Returns the tooltip
+       std::string getDescription(IItemDefManager *itemdef) const;
+       std::string getShortDescription(IItemDefManager *itemdef) const;
 
        /*
                Quantity methods
@@ -110,12 +114,15 @@ struct ItemStack
        const ToolCapabilities& getToolCapabilities(
                        IItemDefManager *itemdef) const
        {
-               ToolCapabilities *cap;
-               cap = itemdef->get(name).tool_capabilities;
-               if(cap == NULL)
-                       cap = itemdef->get("").tool_capabilities;
-               assert(cap != NULL);
-               return *cap;
+               const ToolCapabilities *item_cap =
+                       itemdef->get(name).tool_capabilities;
+
+               if (item_cap == NULL)
+                       // Fall back to the hand's tool capabilities
+                       item_cap = itemdef->get("").tool_capabilities;
+
+               assert(item_cap != NULL);
+               return metadata.getToolCapabilities(*item_cap); // Check for override
        }
 
        // Wear out (only tools)
@@ -132,10 +139,8 @@ struct ItemStack
                                wear += amount;
                        return true;
                }
-               else
-               {
-                       return false;
-               }
+
+               return false;
        }
 
        // If possible, adds newitem to this item.
@@ -159,6 +164,19 @@ struct ItemStack
        // Similar to takeItem, but keeps this ItemStack intact.
        ItemStack peekItem(u32 peekcount) const;
 
+       bool operator ==(const ItemStack &s) const
+       {
+               return (this->name     == s.name &&
+                               this->count    == s.count &&
+                               this->wear     == s.wear &&
+                               this->metadata == s.metadata);
+       }
+
+       bool operator !=(const ItemStack &s) const
+       {
+               return !(*this == s);
+       }
+
        /*
                Properties
        */
@@ -177,10 +195,10 @@ class InventoryList
        void setSize(u32 newsize);
        void setWidth(u32 newWidth);
        void setName(const std::string &name);
-       void serialize(std::ostream &os) const;
+       void serialize(std::ostream &os, bool incremental) const;
        void deSerialize(std::istream &is);
 
-       InventoryList(const InventoryList &other);
+       InventoryList(const InventoryList &other) { *this = other; }
        InventoryList & operator = (const InventoryList &other);
        bool operator == (const InventoryList &other) const;
        bool operator != (const InventoryList &other) const
@@ -188,16 +206,25 @@ class InventoryList
                return !(*this == other);
        }
 
-       const std::string &getName() const;
-       u32 getSize() const;
-       u32 getWidth() const;
+       const std::string &getName() const { return m_name; }
+       u32 getSize() const { return static_cast<u32>(m_items.size()); }
+       u32 getWidth() const { return m_width; }
        // Count used slots
        u32 getUsedSlots() const;
-       u32 getFreeSlots() const;
 
        // Get reference to item
-       const ItemStack& getItem(u32 i) const;
-       ItemStack& getItem(u32 i);
+       const ItemStack &getItem(u32 i) const
+       {
+               assert(i < m_size); // Pre-condition
+               return m_items[i];
+       }
+       ItemStack &getItem(u32 i)
+       {
+               assert(i < m_size); // Pre-condition
+               return m_items[i];
+       }
+       // Get reference to all items
+       const std::vector<ItemStack> &getItems() const { return m_items; }
        // Returns old item. Parameter can be an empty item.
        ItemStack changeItem(u32 i, const ItemStack &newitem);
        // Delete item
@@ -248,12 +275,16 @@ class InventoryList
        // also with optional rollback recording
        void moveItemSomewhere(u32 i, InventoryList *dest, u32 count);
 
+       inline bool checkModified() const { return m_dirty; }
+       inline void setModified(bool dirty = true) { m_dirty = dirty; }
+
 private:
        std::vector<ItemStack> m_items;
        std::string m_name;
-       u32 m_size;
+       u32 m_size; // always the same as m_items.size()
        u32 m_width = 0;
        IItemDefManager *m_itemdef;
+       bool m_dirty = true;
 };
 
 class Inventory
@@ -262,7 +293,6 @@ class Inventory
        ~Inventory();
 
        void clear();
-       void clearContents();
 
        Inventory(IItemDefManager *itemdef);
        Inventory(const Inventory &other);
@@ -273,39 +303,51 @@ class Inventory
                return !(*this == other);
        }
 
-       void serialize(std::ostream &os) const;
+       // Never ever serialize to disk using "incremental"!
+       void serialize(std::ostream &os, bool incremental = false) const;
        void deSerialize(std::istream &is);
 
+       // Creates a new list if none exists or truncates existing lists
        InventoryList * addList(const std::string &name, u32 size);
        InventoryList * getList(const std::string &name);
        const InventoryList * getList(const std::string &name) const;
-       std::vector<const InventoryList*> getLists();
+       const std::vector<InventoryList *> &getLists() const { return m_lists; }
        bool deleteList(const std::string &name);
        // A shorthand for adding items. Returns leftover item (possibly empty).
        ItemStack addItem(const std::string &listname, const ItemStack &newitem)
        {
-               m_dirty = true;
                InventoryList *list = getList(listname);
                if(list == NULL)
                        return newitem;
                return list->addItem(newitem);
        }
 
-       bool checkModified() const
+       inline bool checkModified() const
        {
-               return m_dirty;
+               if (m_dirty)
+                       return true;
+
+               for (const auto &list : m_lists)
+                       if (list->checkModified())
+                               return true;
+
+               return false;
        }
 
-       void setModified(const bool x)
+       inline void setModified(bool dirty = true)
        {
-               m_dirty = x;
+               m_dirty = dirty;
+               // Set all as handled
+               if (!dirty) {
+                       for (const auto &list : m_lists)
+                               list->setModified(dirty);
+               }
        }
-
 private:
        // -1 if not found
-       const s32 getListIndex(const std::string &name) const;
+       s32 getListIndex(const std::string &name) const;
 
        std::vector<InventoryList*> m_lists;
        IItemDefManager *m_itemdef;
-       bool m_dirty = false;
+       bool m_dirty = true;
 };