X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Finventory.h;h=8b31de3a8ae39ee563764fd09991e89ef11fad51;hb=7f4fc6f8a77cd0e454ce98ff92da8c8d6592afba;hp=fcac5f647153cb9ecbf110ebe9888ac066610f67;hpb=b4dd5d3bd7d2152fdf02e0e7422b1305caf151f2;p=dragonfireclient.git diff --git a/src/inventory.h b/src/inventory.h index fcac5f647..8b31de3a8 100644 --- a/src/inventory.h +++ b/src/inventory.h @@ -1,50 +1,55 @@ /* -Minetest-c55 -Copyright (C) 2010-2011 celeron55, Perttu Ahola +Minetest +Copyright (C) 2010-2013 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef INVENTORY_HEADER -#define INVENTORY_HEADER +#pragma once -#include -#include +#include "itemdef.h" +#include "irrlichttypes.h" +#include "itemstackmetadata.h" +#include +#include #include #include -#include "common_irrlicht.h" -#include "debug.h" -#include "itemdef.h" +#include -struct ToolDiggingProperties; +struct ToolCapabilities; struct ItemStack { - ItemStack(): name(""), count(0), wear(0), metadata("") {} - ItemStack(std::string name_, u16 count_, - u16 wear, std::string metadata_, - IItemDefManager *itemdef); - ~ItemStack() {} + ItemStack() = default; + + ItemStack(const std::string &name_, u16 count_, + u16 wear, IItemDefManager *itemdef); + + ~ItemStack() = default; // Serialization - void serialize(std::ostream &os) const; - void deSerialize(std::istream &is, IItemDefManager *itemdef); - void deSerialize(const std::string &s, IItemDefManager *itemdef); + 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 @@ -60,7 +65,7 @@ struct ItemStack name = ""; count = 0; wear = 0; - metadata = ""; + metadata.clear(); } void add(u16 n) @@ -70,7 +75,7 @@ struct ItemStack void remove(u16 n) { - assert(count >= n); + assert(count >= n); // Pre-condition count -= n; if(count == 0) clear(); // reset name, wear and metadata too @@ -79,15 +84,14 @@ struct ItemStack // Maximum size of a stack u16 getStackMax(IItemDefManager *itemdef) const { - s16 max = itemdef->get(name).stack_max; - return (max >= 0) ? max : 0; + return itemdef->get(name).stack_max; } // Number of items that can be added to this stack u16 freeSpace(IItemDefManager *itemdef) const { u16 max = getStackMax(itemdef); - if(count > max) + if (count >= max) return 0; return max - count; } @@ -107,15 +111,18 @@ struct ItemStack } // Get tool digging properties, or those of the hand if not a tool - const ToolDiggingProperties& getToolDiggingProperties( + const ToolCapabilities& getToolCapabilities( IItemDefManager *itemdef) const { - ToolDiggingProperties *prop; - prop = itemdef->get(name).tool_digging_properties; - if(prop == NULL) - prop = itemdef->get("").tool_digging_properties; - assert(prop != NULL); - return *prop; + 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,23 +139,20 @@ struct ItemStack wear += amount; return true; } - else - { - return false; - } + + return false; } // If possible, adds newitem to this item. // If cannot be added at all, returns the item back. // If can be added partly, decremented item is returned back. // If can be added fully, empty item is returned. - ItemStack addItem(const ItemStack &newitem, - IItemDefManager *itemdef); + ItemStack addItem(ItemStack newitem, IItemDefManager *itemdef); // Checks whether newitem could be added. // If restitem is non-NULL, it receives the part of newitem that // would be left over after adding. - bool itemFits(const ItemStack &newitem, + bool itemFits(ItemStack newitem, ItemStack *restitem, // may be NULL IItemDefManager *itemdef) const; @@ -160,37 +164,67 @@ 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 */ - std::string name; - u16 count; - u16 wear; - std::string metadata; + std::string name = ""; + u16 count = 0; + u16 wear = 0; + ItemStackMetadata metadata; }; class InventoryList { public: - InventoryList(std::string name, u32 size, IItemDefManager *itemdef); - ~InventoryList(); + InventoryList(const std::string &name, u32 size, IItemDefManager *itemdef); + ~InventoryList() = default; void clearItems(); void setSize(u32 newsize); - void serialize(std::ostream &os) const; + void setWidth(u32 newWidth); + void setName(const std::string &name); + 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 + { + return !(*this == other); + } - const std::string &getName() const; - u32 getSize() const; + const std::string &getName() const { return m_name; } + u32 getSize() const { return static_cast(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 &getItems() const { return m_items; } // Returns old item. Parameter can be an empty item. ItemStack changeItem(u32 i, const ItemStack &newitem); // Delete item @@ -214,9 +248,10 @@ class InventoryList // Checks whether there is room for a given item bool roomForItem(const ItemStack &item) const; - // Checks whether the given count of the given item name + // Checks whether the given count of the given item // exists in this inventory list. - bool containsItem(const ItemStack &item) const; + // If match_meta is false, only the items' names are compared. + bool containsItem(const ItemStack &item, bool match_meta) const; // Removes the given count of the given item name from // this inventory list. Walks the list in reverse order. @@ -230,18 +265,26 @@ class InventoryList // Returns empty item if couldn't take any. ItemStack takeItem(u32 i, u32 takecount); - // Similar to takeItem, but keeps the slot intact. - ItemStack peekItem(u32 i, u32 peekcount) const; - // Move an item to a different list (or a different stack in the same list) // count is the maximum number of items to move (0 for everything) - void moveItem(u32 i, InventoryList *dest, u32 dest_i, u32 count = 0); + // returns number of moved items + u32 moveItem(u32 i, InventoryList *dest, u32 dest_i, + u32 count = 0, bool swap_if_needed = true, bool *did_swap = NULL); + + // like moveItem, but without a fixed destination index + // 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 m_items; - u32 m_size; std::string m_name; + u32 m_size; // always the same as m_items.size() + u32 m_width = 0; IItemDefManager *m_itemdef; + bool m_dirty = true; }; class Inventory @@ -254,13 +297,21 @@ class Inventory Inventory(IItemDefManager *itemdef); Inventory(const Inventory &other); Inventory & operator = (const Inventory &other); - - void serialize(std::ostream &os) const; + bool operator == (const Inventory &other) const; + bool operator != (const Inventory &other) const + { + return !(*this == other); + } + + // 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; + const std::vector &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) @@ -270,14 +321,33 @@ class Inventory return newitem; return list->addItem(newitem); } - + + inline bool checkModified() const + { + if (m_dirty) + return true; + + for (const auto &list : m_lists) + if (list->checkModified()) + return true; + + return false; + } + + inline void setModified(bool dirty = true) + { + 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 m_lists; IItemDefManager *m_itemdef; + bool m_dirty = true; }; - -#endif -