X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Finventory.h;h=cd592a17ac9cfe0375eac4a13ba77ecf9176c097;hb=1e4e64f83195ed1be0aa0c4a237a50de6dd132a9;hp=cb5b54851b99ef30306840f41d40f528f0611d50;hpb=ab7477c4c3e2a3647dc4fb65c71567946d33b0e3;p=dragonfireclient.git

diff --git a/src/inventory.h b/src/inventory.h
index cb5b54851..cd592a17a 100644
--- a/src/inventory.h
+++ b/src/inventory.h
@@ -1,224 +1,288 @@
 /*
-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"
 
-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;
-	// Shall return an image to show in the GUI (or NULL)
-	virtual video::ITexture * getImage() { return NULL; }
-	// 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;
+	void deSerialize(std::istream &is, IItemDefManager *itemdef);
+	void deSerialize(const std::string &s, IItemDefManager *itemdef);
 
-#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_texturecache.get(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);
+		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;
-	}
-	void add(u16 count)
-	{
-		assert(m_count + count <= MATERIAL_ITEM_MAX_COUNT);
-		m_count += count;
+		return max - 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)
+	// 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 = obj->getInventoryString();
-	}*/
-	MapBlockObjectItem(std::string inventorystring)
-	{
-		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);
 	}
 
-	video::ITexture * getImage();
-	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);
+
+	// 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 getInventoryString()
-	{
-		return m_inventorystring;
-	}
+	std::string name;
+	u16 count;
+	u16 wear;
+	std::string metadata;
+};
+
+class InventoryList
+{
+public:
+	InventoryList(std::string name, u32 size, IItemDefManager *itemdef);
+	~InventoryList();
+	void clearItems();
+	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);
 
-	MapBlockObject * createObject(v3f pos, f32 player_yaw, f32 player_pitch);
+	const std::string &getName() const;
+	u32 getSize() const;
+	u32 getWidth() const;
+	// Count used slots
+	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 (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)
+	void moveItem(u32 i, InventoryList *dest, u32 dest_i, u32 count = 0);
 
 private:
-	std::string m_inventorystring;
+	std::vector<ItemStack> m_items;
+	u32 m_size, m_width;
+	std::string m_name;
+	IItemDefManager *m_itemdef;
 };
 
-//SUGGESTION: Split into ClientInventory and ServerInventory
 class Inventory
 {
 public:
-	Inventory(u32 size);
 	~Inventory();
-	void clearItems();
-	void serialize(std::ostream &os);
-	void deSerialize(std::istream &is);
 
-	Inventory & operator = (Inventory &other);
+	void clear();
+	void clearContents();
 
-	u32 getSize();
-	u32 getUsedSlots();
+	Inventory(IItemDefManager *itemdef);
+	Inventory(const Inventory &other);
+	Inventory & operator = (const Inventory &other);
+	bool operator == (const Inventory &other);
 	
-	InventoryItem * getItem(u32 i);
-	// Returns old item (or NULL). Parameter can be NULL.
-	InventoryItem * changeItem(u32 i, InventoryItem *newitem);
-	void deleteItem(u32 i);
-	// Adds an item to a suitable place. Returns false if failed.
-	bool addItem(InventoryItem *newitem);
+	void serialize(std::ostream &os) const;
+	void deSerialize(std::istream &is);
 
-	void print(std::ostream &o);
+	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 leftover item (possibly empty).
+	ItemStack addItem(const std::string &listname, const ItemStack &newitem)
+	{
+		InventoryList *list = getList(listname);
+		if(list == NULL)
+			return newitem;
+		return list->addItem(newitem);
+	}
 	
 private:
-	core::array<InventoryItem*> m_items;
-	u32 m_size;
+	// -1 if not found
+	const s32 getListIndex(const std::string &name) const;
+
+	std::vector<InventoryList*> m_lists;
+	IItemDefManager *m_itemdef;
 };
 
 #endif