X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Finventory.h;h=67a7859ed14dafc9baa35913d27766f79f6ce1d2;hb=1780adeea63630e67f4af8b300f6ae710d9af486;hp=ffe944a137c250af1512f0fe88f84ac208de3189;hpb=497ff1ecd64c8908f988e15ca879824f2781e3fd;p=dragonfireclient.git diff --git a/src/inventory.h b/src/inventory.h index ffe944a13..67a7859ed 100644 --- a/src/inventory.h +++ b/src/inventory.h @@ -1,6 +1,6 @@ /* Minetest -Copyright (C) 2010-2011 celeron55, Perttu Ahola +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 Lesser General Public License as published by @@ -17,34 +17,38 @@ 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 "irrlichttypes_bloated.h" -#include "debug.h" -#include "itemdef.h" +#include 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; /* Quantity methods @@ -60,7 +64,7 @@ struct ItemStack name = ""; count = 0; wear = 0; - metadata = ""; + metadata.clear(); } void add(u16 n) @@ -70,7 +74,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 +83,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; } @@ -110,12 +113,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,23 +138,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,29 +163,47 @@ 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 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 & 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; @@ -217,9 +238,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. @@ -233,18 +255,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, m_width; std::string m_name; + u32 m_size; + u32 m_width = 0; IItemDefManager *m_itemdef; + bool m_dirty = true; }; class Inventory @@ -253,13 +283,18 @@ class Inventory ~Inventory(); void clear(); - void clearContents(); 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); InventoryList * addList(const std::string &name, u32 size); @@ -275,14 +310,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; std::vector m_lists; IItemDefManager *m_itemdef; + bool m_dirty = true; }; - -#endif -