// For g_materials
#include "main.h"
+#define QUANTITY_ITEM_MAX_COUNT 99
+
class InventoryItem
{
public:
- InventoryItem();
+ InventoryItem(u16 count);
virtual ~InventoryItem();
static InventoryItem* deSerialize(std::istream &is);
// Shall return a text to show in the GUI
virtual std::string getText() { return ""; }
-private:
-};
+ // 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;
+ }
-#define MATERIAL_ITEM_MAX_COUNT 99
+protected:
+ u16 m_count;
+};
class MaterialItem : public InventoryItem
{
public:
- MaterialItem(u8 content, u16 count)
+ MaterialItem(u8 content, u16 count):
+ InventoryItem(count)
{
m_content = content;
- m_count = count;
}
/*
Implementation interface
#ifndef SERVER
video::ITexture * getImage()
{
- /*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]);
+ return content_features(m_content).inventory_texture;
+ return NULL;
}
#endif
std::string getText()
os<<m_count;
return os.str();
}
- /*
- Special methods
- */
- u8 getMaterial()
- {
- return m_content;
- }
- u16 getCount()
+
+ virtual bool addableTo(InventoryItem *other)
{
- return m_count;
+ if(std::string(other->getName()) != "MaterialItem")
+ return false;
+ MaterialItem *m = (MaterialItem*)other;
+ if(m->getMaterial() != m_content)
+ return false;
+ return true;
}
u16 freeSpace()
{
- if(m_count > MATERIAL_ITEM_MAX_COUNT)
+ if(m_count > QUANTITY_ITEM_MAX_COUNT)
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 QUANTITY_ITEM_MAX_COUNT - m_count;
}
- void remove(u16 count)
+ /*
+ Special methods
+ */
+ u8 getMaterial()
{
- assert(m_count >= count);
- m_count -= count;
+ return m_content;
}
private:
u8 m_content;
- u16 m_count;
};
class MapBlockObjectItem : public InventoryItem
{
public:
- /*MapBlockObjectItem(MapBlockObject *obj)
- {
- m_inventorystring = obj->getInventoryString();
- }*/
- MapBlockObjectItem(std::string inventorystring)
+ MapBlockObjectItem(std::string inventorystring):
+ InventoryItem(1)
{
m_inventorystring = inventorystring;
}
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
+ {
+ return "CraftItem";
+ }
+ 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()
+ {
+ if(g_texturesource == NULL)
+ return NULL;
+
+ std::string name;
+
+ if(m_subname == "Stick")
+ name = "stick.png";
+ else if(m_subname == "lump_of_coal")
+ name = "lump_of_coal.png";
+ else if(m_subname == "lump_of_iron")
+ name = "lump_of_iron.png";
+ else
+ name = "cloud.png";
+
+ // Get such a texture
+ //return g_irrlicht->getTexture(name);
+ return g_texturesource->getTextureRaw(name);
+ }
+#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)
+ ToolItem(std::string toolname, u16 wear):
+ InventoryItem(1)
{
m_toolname = toolname;
m_wear = wear;
#ifndef SERVER
video::ITexture * getImage()
{
+ if(g_texturesource == NULL)
+ return NULL;
+
std::string basename;
if(m_toolname == "WPick")
- basename = "../data/tool_wpick.png";
+ basename = "tool_wpick.png";
else if(m_toolname == "STPick")
- basename = "../data/tool_stpick.png";
- // Default to cloud texture
+ basename = "tool_stpick.png";
+ else if(m_toolname == "MesePick")
+ basename = "tool_mesepick.png";
else
- basename = tile_texture_path_get(TILE_CLOUD);
+ basename = "cloud.png";
/*
- Calculate some progress value with sane amount of
+ Calculate a 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
+ float value_f = (float)toolprogress / (float)maxprogress;
std::ostringstream os;
- os<<basename<<"-toolprogress-"<<toolprogress;
- std::string finalname = os.str();
+ os<<basename<<"^[progressbar"<<value_f;
- 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));
+ return g_texturesource->getTextureRaw(os.str());
+
+ /*TextureSpec spec;
+ spec.addTid(g_irrlicht->getTextureId(basename));
+ spec.addTid(g_irrlicht->getTextureId(os.str()));
+ return g_irrlicht->getTexture(spec);*/
}
#endif
std::string getText()
{
return m_wear;
}
+ // Returns true if weared out
+ bool addWear(u16 add)
+ {
+ if(m_wear >= 65535 - add)
+ {
+ m_wear = 65535;
+ return true;
+ }
+ else
+ {
+ m_wear += add;
+ return false;
+ }
+ }
private:
std::string m_toolname;
u16 m_wear;
InventoryItem * changeItem(u32 i, InventoryItem *newitem);
// Delete item
void deleteItem(u32 i);
- // Adds an item to a suitable place. Returns false if failed.
- bool addItem(InventoryItem *newitem);
- // If possible, adds item to given slot. Returns true on success.
- // Fails when slot is populated by a different kind of item.
- bool addItem(u32 i, InventoryItem *newitem);
+ // Adds an item to a suitable place. Returns leftover item.
+ // If all went into the list, returns NULL.
+ InventoryItem * addItem(InventoryItem *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);
+
+ // 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);
// Decrements amount of every material item
void decrementMaterials(u16 count);
InventoryList * addList(const std::string &name, u32 size);
InventoryList * getList(const std::string &name);
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 NULL if the item was fully added, leftover otherwise.
+ InventoryItem * addItem(const std::string &listname, InventoryItem *newitem)
{
InventoryList *list = getList(listname);
if(list == NULL)
- return false;
+ return newitem;
return list->addItem(newitem);
}
struct IMoveAction : public InventoryAction
{
+ // count=0 means "everything"
u16 count;
std::string from_name;
s16 from_i;