X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Finventory.h;h=a690eb5ae29d825b4635888d23d1a0aa407fb738;hb=d1df09841d0eac7a88f638676b80ec848522cca5;hp=d37761cfedfc3906eaf4fcef49a693b3acc10f15;hpb=2e41a5e304d9c35ece851b8a65482bca8784b582;p=dragonfireclient.git

diff --git a/src/inventory.h b/src/inventory.h
index d37761cfe..a690eb5ae 100644
--- a/src/inventory.h
+++ b/src/inventory.h
@@ -1,231 +1,262 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 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 <celeron55@gmail.com>
-*/
-
 #ifndef INVENTORY_HEADER
 #define INVENTORY_HEADER
 
-#include <iostream>
-#include <sstream>
-#include <string>
-#include "common_irrlicht.h"
 #include "debug.h"
-#include "mapblockobject.h"
-// For g_materials
-#include "main.h"
+#include "itemdef.h"
+#include "irrlichttypes.h"
+#include <istream>
+#include <ostream>
+#include <string>
+#include <vector>
 
-class InventoryItem
+struct ToolCapabilities;
+
+struct ItemStack
 {
-public:
-	InventoryItem();
-	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() {}
 
-private:
-};
+	// 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);
 
-#define MATERIAL_ITEM_MAX_COUNT 99
+	// Returns the string used for inventory
+	std::string getItemString() const;
 
-class MaterialItem : public InventoryItem
-{
-public:
-	MaterialItem(u8 content, u16 count)
-	{
-		m_content = content;
-		m_count = count;
-	}
 	/*
-		Implementation interface
+		Quantity methods
 	*/
-	virtual const char* getName() const
-	{
-		return "MaterialItem";
-	}
-	virtual void serialize(std::ostream &os)
-	{
-		//os.imbue(std::locale("C"));
-		os<<getName();
-		os<<" ";
-		os<<(unsigned int)m_content;
-		os<<" ";
-		os<<m_count;
-	}
-	virtual InventoryItem* clone()
+
+	bool empty() const
 	{
-		return new MaterialItem(m_content, m_count);
+		return count == 0;
 	}
-#ifndef SERVER
-	video::ITexture * getImage()
+
+	void clear()
 	{
-		/*if(m_content == CONTENT_TORCH)
-			return g_texturecache.get("torch_on_floor");
-
-		u16 tile = content_tile(m_content, v3s16(1,0,0));
-		return g_tile_contents[tile].getTexture(0);*/
-		
-		if(m_content >= USEFUL_CONTENT_COUNT)
-			return NULL;
-			
-		return g_irrlicht->getTexture(g_content_inventory_textures[m_content]);
+		name = "";
+		count = 0;
+		wear = 0;
+		metadata = "";
 	}
-#endif
-	std::string getText()
+
+	void add(u16 n)
 	{
-		std::ostringstream os;
-		os<<m_count;
-		return os.str();
+		count += n;
 	}
-	/*
-		Special methods
-	*/
-	u8 getMaterial()
+
+	void remove(u16 n)
 	{
-		return m_content;
+		assert(count >= n); // Pre-condition
+		count -= n;
+		if(count == 0)
+			clear(); // reset name, wear and metadata too
 	}
-	u16 getCount()
+
+	// Maximum size of a stack
+	u16 getStackMax(IItemDefManager *itemdef) const
 	{
-		return m_count;
+		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 > MATERIAL_ITEM_MAX_COUNT)
+		u16 max = getStackMax(itemdef);
+		if(count > max)
 			return 0;
-		return MATERIAL_ITEM_MAX_COUNT - m_count;
+		return max - count;
 	}
-	void add(u16 count)
-	{
-		assert(m_count + count <= MATERIAL_ITEM_MAX_COUNT);
-		m_count += count;
-	}
-	void remove(u16 count)
+
+	// Returns false if item is not known and cannot be used
+	bool isKnown(IItemDefManager *itemdef) const
 	{
-		assert(m_count >= count);
-		m_count -= count;
+		return itemdef->isKnown(name);
 	}
-private:
-	u8 m_content;
-	u16 m_count;
-};
 
-class MapBlockObjectItem : public InventoryItem
-{
-public:
-	/*MapBlockObjectItem(MapBlockObject *obj)
-	{
-		m_inventorystring = obj->getInventoryString();
-	}*/
-	MapBlockObjectItem(std::string inventorystring)
+	// Returns a pointer to the item definition struct,
+	// or a fallback one (name="unknown") if the item is unknown.
+	const ItemDefinition& getDefinition(
+			IItemDefManager *itemdef) const
 	{
-		m_inventorystring = inventorystring;
+		return itemdef->get(name);
 	}
-	
-	/*
-		Implementation interface
-	*/
-	virtual const char* getName() const
+
+	// Get tool digging properties, or those of the hand if not a tool
+	const ToolCapabilities& getToolCapabilities(
+			IItemDefManager *itemdef) const
 	{
-		return "MBOItem";
+		ToolCapabilities *cap;
+		cap = itemdef->get(name).tool_capabilities;
+		if(cap == NULL)
+			cap = itemdef->get("").tool_capabilities;
+		assert(cap != NULL);
+		return *cap;
 	}
-	virtual void serialize(std::ostream &os)
+
+	// Wear out (only tools)
+	// Returns true if the item is (was) a tool
+	bool addWear(s32 amount, IItemDefManager *itemdef)
 	{
-		for(;;)
+		if(getDefinition(itemdef).type == ITEM_TOOL)
 		{
-			size_t t = m_inventorystring.find('|');
-			if(t == std::string::npos)
-				break;
-			m_inventorystring[t] = '?';
+			if(amount > 65535 - wear)
+				clear();
+			else if(amount < -wear)
+				wear = 0;
+			else
+				wear += amount;
+			return true;
+		}
+		else
+		{
+			return false;
 		}
-		os<<getName();
-		os<<" ";
-		os<<m_inventorystring;
-		os<<"|";
-	}
-	virtual InventoryItem* clone()
-	{
-		return new MapBlockObjectItem(m_inventorystring);
 	}
 
-#ifndef SERVER
-	video::ITexture * getImage();
-#endif
-	std::string getText();
+	// 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);
 
-	/*
-		Special methods
-	*/
-	std::string getInventoryString()
-	{
-		return m_inventorystring;
-	}
+	// 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;
 
-	MapBlockObject * createObject(v3f pos, f32 player_yaw, f32 player_pitch);
+	// 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);
 
-private:
-	std::string m_inventorystring;
+	// 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();
-	
-	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 false if failed.
-	bool addItem(InventoryItem *newitem);
 
-	void print(std::ostream &o);
-	
+	// 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, 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 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);
+
+	// like moveItem, but without a fixed destination index
+	// also with optional rollback recording
+	void moveItemSomewhere(u32 i, InventoryList *dest, u32 count);
+
 private:
-	core::array<InventoryItem*> m_items;
-	u32 m_size;
+	std::vector<ItemStack> m_items;
+	u32 m_size, m_width;
 	std::string m_name;
+	IItemDefManager *m_itemdef;
 };
 
 class Inventory
@@ -234,31 +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<const InventoryList*> getLists();
 	bool deleteList(const std::string &name);
-	// A shorthand for adding items
-	bool 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 false;
+			return newitem;
 		return list->addItem(newitem);
 	}
-	
+
+	bool checkModified() const
+	{
+		return m_dirty;
+	}
+
+	void setModified(const bool x)
+	{
+		m_dirty = x;
+	}
+
 private:
 	// -1 if not found
-	s32 getListIndex(const std::string &name);
+	const s32 getListIndex(const std::string &name) const;
 
-	core::array<InventoryList*> m_lists;
+	std::vector<InventoryList*> m_lists;
+	IItemDefManager *m_itemdef;
+	bool m_dirty;
 };
 
 #endif