X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Finventory.h;h=a690eb5ae29d825b4635888d23d1a0aa407fb738;hb=d1df09841d0eac7a88f638676b80ec848522cca5;hp=84ccd5bd6306c19007a515f50a1f0f473ae49422;hpb=6b6c2d37ea1f9075c4fbf0d7e2d52e527e1f86aa;p=dragonfireclient.git diff --git a/src/inventory.h b/src/inventory.h index 84ccd5bd6..a690eb5ae 100644 --- a/src/inventory.h +++ b/src/inventory.h @@ -1,463 +1,262 @@ /* -Minetest-c55 -Copyright (C) 2010 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. */ -/* -(c) 2010 Perttu Ahola -*/ - #ifndef INVENTORY_HEADER #define INVENTORY_HEADER -#include -#include -#include -#include "common_irrlicht.h" #include "debug.h" -#include "mapblockobject.h" -// For g_materials -#include "main.h" +#include "itemdef.h" +#include "irrlichttypes.h" +#include +#include +#include +#include -#define QUANTITY_ITEM_MAX_COUNT 99 +struct ToolCapabilities; -class InventoryItem +struct ItemStack { -public: - InventoryItem(u16 count); - virtual ~InventoryItem(); - - static InventoryItem* deSerialize(std::istream &is); - - virtual const char* getName() const = 0; - // Shall write the name and the parameters - virtual void serialize(std::ostream &os) = 0; - // Shall make an exact clone of the item - virtual InventoryItem* clone() = 0; -#ifndef SERVER - // Shall return an image to show in the GUI (or NULL) - virtual video::ITexture * getImage() { return NULL; } -#endif - // Shall return a text to show in the GUI - virtual std::string getText() { return ""; } + ItemStack(): name(""), count(0), wear(0), metadata("") {} + ItemStack(std::string name_, u16 count_, + u16 wear, std::string metadata_, + IItemDefManager *itemdef); + ~ItemStack() {} - // Shall return true if the item can be add()ed to the other - virtual bool addableTo(InventoryItem *other) - { - return false; - } - - /* - Quantity methods - */ - u16 getCount() - { - return m_count; - } - void setCount(u16 count) - { - m_count = count; - } - virtual u16 freeSpace() - { - return 0; - } - void add(u16 count) - { - assert(m_count + count <= QUANTITY_ITEM_MAX_COUNT); - m_count += count; - } - void remove(u16 count) - { - assert(m_count >= count); - m_count -= count; - } + // Serialization + void serialize(std::ostream &os) 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); -protected: - u16 m_count; -}; + // Returns the string used for inventory + std::string getItemString() const; -class MaterialItem : public InventoryItem -{ -public: - MaterialItem(u8 content, u16 count): - InventoryItem(count) - { - m_content = content; - } /* - Implementation interface + Quantity methods */ - virtual const char* getName() const - { - return "MaterialItem"; - } - virtual void serialize(std::ostream &os) - { - //os.imbue(std::locale("C")); - os<= USEFUL_CONTENT_COUNT) - return NULL; - - return g_irrlicht->getTexture(g_content_inventory_texture_paths[m_content]); - } -#endif - std::string getText() - { - std::ostringstream os; - os<getName()) != "MaterialItem") - return false; - MaterialItem *m = (MaterialItem*)other; - if(m->getMaterial() != m_content) - return false; - return true; - } - u16 freeSpace() + bool empty() const { - if(m_count > QUANTITY_ITEM_MAX_COUNT) - return 0; - return QUANTITY_ITEM_MAX_COUNT - m_count; + return count == 0; } - /* - Special methods - */ - u8 getMaterial() - { - return m_content; - } -private: - u8 m_content; -}; -class MapBlockObjectItem : public InventoryItem -{ -public: - MapBlockObjectItem(std::string inventorystring): - InventoryItem(1) - { - m_inventorystring = inventorystring; - } - - /* - Implementation interface - */ - virtual const char* getName() const - { - return "MBOItem"; - } - virtual void serialize(std::ostream &os) - { - for(;;) - { - size_t t = m_inventorystring.find('|'); - if(t == std::string::npos) - break; - m_inventorystring[t] = '?'; - } - os<getTexture(basename); - //return g_irrlicht->getTexture(TextureSpec(finalname, basename, mod)); + assert(count >= n); // Pre-condition + count -= n; + if(count == 0) + clear(); // reset name, wear and metadata too } -#endif - std::string getText() - { - std::ostringstream os; - os<getName()) != "CraftItem") - return false; - CraftItem *m = (CraftItem*)other; - if(m->m_subname != m_subname) - return false; - return true; + s16 max = itemdef->get(name).stack_max; + return (max >= 0) ? max : 0; } - u16 freeSpace() + + // Number of items that can be added to this stack + u16 freeSpace(IItemDefManager *itemdef) const { - if(m_count > QUANTITY_ITEM_MAX_COUNT) + u16 max = getStackMax(itemdef); + if(count > max) return 0; - return QUANTITY_ITEM_MAX_COUNT - m_count; + return max - count; } - /* - Special methods - */ - std::string getSubName() - { - return m_subname; - } -private: - std::string m_subname; -}; -class ToolItem : public InventoryItem -{ -public: - ToolItem(std::string toolname, u16 wear): - InventoryItem(1) + // Returns false if item is not known and cannot be used + bool isKnown(IItemDefManager *itemdef) const { - m_toolname = toolname; - m_wear = wear; + return itemdef->isKnown(name); } - /* - Implementation interface - */ - virtual const char* getName() const - { - return "ToolItem"; - } - virtual void serialize(std::ostream &os) - { - os<getTexture(TextureSpec(finalname, basename, mod)); - } -#endif - std::string getText() - { - return ""; - - /*std::ostringstream os; - u16 f = 4; - u16 d = 65535/f; - u16 i; - for(i=0; i<(65535-m_wear)/d; i++) - os<<'X'; - for(; iget(name); } - u16 getWear() + + // Get tool digging properties, or those of the hand if not a tool + const ToolCapabilities& getToolCapabilities( + IItemDefManager *itemdef) const { - return m_wear; + ToolCapabilities *cap; + cap = itemdef->get(name).tool_capabilities; + if(cap == NULL) + cap = itemdef->get("").tool_capabilities; + assert(cap != NULL); + return *cap; } - // Returns true if weared out - bool addWear(u16 add) + + // Wear out (only tools) + // Returns true if the item is (was) a tool + bool addWear(s32 amount, IItemDefManager *itemdef) { - if(m_wear >= 65535 - add) + if(getDefinition(itemdef).type == ITEM_TOOL) { - m_wear = 65535; + if(amount > 65535 - wear) + clear(); + else if(amount < -wear) + wear = 0; + else + wear += amount; return true; } else { - m_wear += add; return false; } } -private: - std::string m_toolname; - u16 m_wear; + + // 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); + + // 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, + ItemStack *restitem, // may be NULL + IItemDefManager *itemdef) const; + + // Takes some items. + // If there are not enough, takes as many as it can. + // Returns empty item if couldn't take any. + ItemStack takeItem(u32 takecount); + + // Similar to takeItem, but keeps this ItemStack intact. + ItemStack peekItem(u32 peekcount) const; + + /* + Properties + */ + std::string name; + u16 count; + u16 wear; + std::string metadata; }; class InventoryList { public: - InventoryList(std::string name, u32 size); + InventoryList(std::string name, u32 size, IItemDefManager *itemdef); ~InventoryList(); void clearItems(); - void serialize(std::ostream &os); + void setSize(u32 newsize); + void setWidth(u32 newWidth); + void setName(const std::string &name); + void serialize(std::ostream &os) 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); + } - std::string getName(); - u32 getSize(); + const std::string &getName() const; + u32 getSize() const; + u32 getWidth() const; // Count used slots - u32 getUsedSlots(); - - // Get pointer to item - InventoryItem * getItem(u32 i); - // Returns old item (or NULL). Parameter can be NULL. - InventoryItem * changeItem(u32 i, InventoryItem *newitem); + u32 getUsedSlots() const; + u32 getFreeSlots() const; + + // Get reference to item + const ItemStack& getItem(u32 i) const; + ItemStack& getItem(u32 i); + // Returns old item. Parameter can be an empty item. + ItemStack changeItem(u32 i, const ItemStack &newitem); // Delete item void deleteItem(u32 i); - // Adds an item to a suitable place. Returns leftover item. - // If all went into the list, returns NULL. - InventoryItem * addItem(InventoryItem *newitem); + + // Adds an item to a suitable place. Returns leftover item (possibly empty). + ItemStack addItem(const ItemStack &newitem); // If possible, adds item to given slot. // 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, NULL is returned. - InventoryItem * addItem(u32 i, InventoryItem *newitem); + // If can be added fully, empty item is returned. + ItemStack addItem(u32 i, const ItemStack &newitem); + + // Checks whether the item could be added to the given slot + // If restitem is non-NULL, it receives the part of newitem that + // would be left over after adding. + bool itemFits(const u32 i, const ItemStack &newitem, + ItemStack *restitem = NULL) const; + + // 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 + // exists in this inventory list. + bool containsItem(const ItemStack &item) const; + + // Removes the given count of the given item name from + // this inventory list. Walks the list in reverse order. + // If not as many items exist as requested, removes as + // many as possible. + // Returns the items that were actually removed. + ItemStack removeItem(const ItemStack &item); // Takes some items from a slot. // If there are not enough, takes as many as it can. - // Returns NULL if couldn't take any. - InventoryItem * takeItem(u32 i, u32 count); + // 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) + // 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); - // Decrements amount of every material item - void decrementMaterials(u16 count); + // like moveItem, but without a fixed destination index + // also with optional rollback recording + void moveItemSomewhere(u32 i, InventoryList *dest, u32 count); - void print(std::ostream &o); - private: - core::array m_items; - u32 m_size; + std::vector m_items; + u32 m_size, m_width; std::string m_name; + IItemDefManager *m_itemdef; }; class Inventory @@ -466,94 +265,52 @@ class Inventory ~Inventory(); void clear(); + void clearContents(); - Inventory(); + Inventory(IItemDefManager *itemdef); Inventory(const Inventory &other); Inventory & operator = (const Inventory &other); - - void serialize(std::ostream &os); + bool operator == (const Inventory &other) const; + bool operator != (const Inventory &other) const + { + return !(*this == other); + } + + void serialize(std::ostream &os) const; void deSerialize(std::istream &is); InventoryList * addList(const std::string &name, u32 size); InventoryList * getList(const std::string &name); + const InventoryList * getList(const std::string &name) const; + std::vector getLists(); bool deleteList(const std::string &name); - // A shorthand for adding items. - // Returns NULL if the item was fully added, leftover otherwise. - InventoryItem * addItem(const std::string &listname, InventoryItem *newitem) + // 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); } - -private: - // -1 if not found - s32 getListIndex(const std::string &name); - core::array m_lists; -}; - -#define IACTION_MOVE 0 - -struct InventoryAction -{ - static InventoryAction * deSerialize(std::istream &is); - - virtual u16 getType() const = 0; - virtual void serialize(std::ostream &os) = 0; - virtual void apply(Inventory *inventory) = 0; -}; - -struct IMoveAction : public InventoryAction -{ - // count=0 means "everything" - u16 count; - std::string from_name; - s16 from_i; - std::string to_name; - s16 to_i; - - IMoveAction() - { - count = 0; - from_i = -1; - to_i = -1; - } - IMoveAction(std::istream &is) + bool checkModified() const { - std::string ts; - - std::getline(is, ts, ' '); - count = stoi(ts); - - std::getline(is, from_name, ' '); - - std::getline(is, ts, ' '); - from_i = stoi(ts); - - std::getline(is, to_name, ' '); - - std::getline(is, ts, ' '); - to_i = stoi(ts); + return m_dirty; } - u16 getType() const + void setModified(const bool x) { - return IACTION_MOVE; + m_dirty = x; } - void serialize(std::ostream &os) - { - os<<"Move "; - os< m_lists; + IItemDefManager *m_itemdef; + bool m_dirty; }; #endif