X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Finventory.h;h=52b776db34684bd4a9dff6e7178e0eec959b446d;hb=58e6d25e033c76dc91aaac18fdeda92ac23fe0e1;hp=13bd27d8bb42e6bf257b42e508c3c46ab336dbaf;hpb=a26c92d7dda327f2b1483fe7250cb27580a0a039;p=oweals%2Fminetest.git

diff --git a/src/inventory.h b/src/inventory.h
index 13bd27d8b..52b776db3 100644
--- a/src/inventory.h
+++ b/src/inventory.h
@@ -1,447 +1,254 @@
 /*
-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 <vector>
+#include "irrlichttypes.h"
 #include "debug.h"
-#include "mapblockobject.h"
-// For g_materials
-#include "main.h"
+#include "itemdef.h"
 
-#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;
+	void deSerialize(std::istream &is, IItemDefManager *itemdef);
+	void deSerialize(const std::string &s, IItemDefManager *itemdef);
 
-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)
+
+	bool empty() const
 	{
-		//os.imbue(std::locale("C"));
-		os<<getName();
-		os<<" ";
-		os<<(unsigned int)m_content;
-		os<<" ";
-		os<<m_count;
+		return count == 0;
 	}
-	virtual InventoryItem* clone()
+
+	void clear()
 	{
-		return new MaterialItem(m_content, m_count);
+		name = "";
+		count = 0;
+		wear = 0;
+		metadata = "";
 	}
-#ifndef SERVER
-	video::ITexture * getImage()
+
+	void add(u16 n)
 	{
-		/*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]);
+		count += n;
 	}
-#endif
-	std::string getText()
+
+	void remove(u16 n)
 	{
-		std::ostringstream os;
-		os<<m_count;
-		return os.str();
+		assert(count >= n);
+		count -= n;
+		if(count == 0)
+			clear(); // reset name, wear and metadata too
 	}
 
-	virtual bool addableTo(InventoryItem *other)
+	// Maximum size of a stack
+	u16 getStackMax(IItemDefManager *itemdef) const
 	{
-		if(std::string(other->getName()) != "MaterialItem")
-			return false;
-		MaterialItem *m = (MaterialItem*)other;
-		if(m->getMaterial() != m_content)
-			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
-	*/
-	u8 getMaterial()
-	{
-		return m_content;
-	}
-private:
-	u8 m_content;
-};
 
-class MapBlockObjectItem : public InventoryItem
-{
-public:
-	MapBlockObjectItem(std::string inventorystring):
-		InventoryItem(1)
+	// Returns false if item is not known and cannot be used
+	bool isKnown(IItemDefManager *itemdef) const
 	{
-		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<<getName();
-		os<<" ";
-		os<<m_inventorystring;
-		os<<"|";
-	}
-	virtual InventoryItem* clone()
-	{
-		return new MapBlockObjectItem(m_inventorystring);
+		return itemdef->isKnown(name);
 	}
 
-#ifndef SERVER
-	video::ITexture * getImage();
-#endif
-	std::string getText();
-
-	/*
-		Special methods
-	*/
-	std::string getInventoryString()
+	// 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
 	{
-		return m_inventorystring;
+		return itemdef->get(name);
 	}
 
-	MapBlockObject * createObject(v3f pos, f32 player_yaw, f32 player_pitch);
-
-private:
-	std::string m_inventorystring;
-};
-
-/*
-	An item that is used as a mid-product when crafting.
-	Subnames:
-	- Stick
-*/
-class CraftItem : public InventoryItem
-{
-public:
-	CraftItem(std::string subname, u16 count):
-		InventoryItem(count)
-	{
-		m_subname = subname;
-	}
-	/*
-		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 "CraftItem";
+		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)
-	{
-		os<<getName();
-		os<<" ";
-		os<<m_subname;
-		os<<" ";
-		os<<m_count;
-	}
-	virtual InventoryItem* clone()
-	{
-		return new CraftItem(m_subname, m_count);
-	}
-#ifndef SERVER
-	video::ITexture * getImage()
+
+	// Wear out (only tools)
+	// Returns true if the item is (was) a tool
+	bool addWear(s32 amount, IItemDefManager *itemdef)
 	{
-		std::string basename;
-		if(m_subname == "Stick")
-			basename = "../data/stick.png";
-		// Default to cloud texture
+		if(getDefinition(itemdef).type == ITEM_TOOL)
+		{
+			if(amount > 65535 - wear)
+				clear();
+			else if(amount < -wear)
+				wear = 0;
+			else
+				wear += amount;
+			return true;
+		}
 		else
-			basename = tile_texture_path_get(TILE_CLOUD);
-		
-		// Get such a texture
-		return g_irrlicht->getTexture(basename);
-		//return g_irrlicht->getTexture(TextureSpec(finalname, basename, mod));
-	}
-#endif
-	std::string getText()
-	{
-		std::ostringstream os;
-		os<<m_count;
-		return os.str();
-	}
-	virtual bool addableTo(InventoryItem *other)
-	{
-		if(std::string(other->getName()) != "CraftItem")
-			return false;
-		CraftItem *m = (CraftItem*)other;
-		if(m->m_subname != m_subname)
+		{
 			return false;
-		return true;
-	}
-	u16 freeSpace()
-	{
-		if(m_count > QUANTITY_ITEM_MAX_COUNT)
-			return 0;
-		return QUANTITY_ITEM_MAX_COUNT - m_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)
-	{
-		m_toolname = toolname;
-		m_wear = wear;
-	}
-	/*
-		Implementation interface
-	*/
-	virtual const char* getName() const
-	{
-		return "ToolItem";
-	}
-	virtual void serialize(std::ostream &os)
-	{
-		os<<getName();
-		os<<" ";
-		os<<m_toolname;
-		os<<" ";
-		os<<m_wear;
-	}
-	virtual InventoryItem* clone()
-	{
-		return new ToolItem(m_toolname, m_wear);
-	}
-#ifndef SERVER
-	video::ITexture * getImage()
-	{
-		std::string basename;
-		if(m_toolname == "WPick")
-			basename = "../data/tool_wpick.png";
-		else if(m_toolname == "STPick")
-			basename = "../data/tool_stpick.png";
-		// Default to cloud texture
-		else
-			basename = tile_texture_path_get(TILE_CLOUD);
-		
-		/*
-			Calculate some progress value with sane amount of
-			maximum states
-		*/
-		u32 maxprogress = 30;
-		u32 toolprogress = (65535-m_wear)/(65535/maxprogress);
-		
-		// Make texture name for the new texture with a progress bar
-		std::ostringstream os;
-		os<<basename<<"-toolprogress-"<<toolprogress;
-		std::string finalname = os.str();
-
-		float value_f = (float)toolprogress / (float)maxprogress;
-		
-		// Get such a texture
-		TextureMod *mod = new ProgressBarTextureMod(value_f);
-		return g_irrlicht->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(; i<f; i++)
-			os<<'-';
-		return os.str();*/
-		
-		/*std::ostringstream os;
-		os<<m_toolname;
-		os<<" ";
-		os<<(m_wear/655);
-		return os.str();*/
-	}
+	// 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;
+
 	/*
-		Special methods
+		Properties
 	*/
-	std::string getToolName()
-	{
-		return m_toolname;
-	}
-	u16 getWear()
-	{
-		return m_wear;
-	}
-private:
-	std::string m_toolname;
-	u16 m_wear;
+	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);
 
-	// Decrements amount of every material item
-	void decrementMaterials(u16 count);
+	// 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);
 
-	void print(std::ostream &o);
-	
 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
@@ -450,20 +257,27 @@ public:
 	~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.
-	// 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)
 	{
 		InventoryList *list = getList(listname);
 		if(list == NULL)
@@ -473,71 +287,10 @@ public:
 	
 private:
 	// -1 if not found
-	s32 getListIndex(const std::string &name);
-
-	core::array<InventoryList*> 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)
-	{
-		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);
-	}
-
-	u16 getType() const
-	{
-		return IACTION_MOVE;
-	}
-
-	void serialize(std::ostream &os)
-	{
-		os<<"Move ";
-		os<<count<<" ";
-		os<<from_name<<" ";
-		os<<from_i<<" ";
-		os<<to_name<<" ";
-		os<<to_i;
-	}
+	const s32 getListIndex(const std::string &name) const;
 
-	void apply(Inventory *inventory);
+	std::vector<InventoryList*> m_lists;
+	IItemDefManager *m_itemdef;
 };
 
 #endif