#include <string>
#include "common_irrlicht.h"
#include "debug.h"
-#include "mapblockobject.h"
-// For g_materials
-#include "main.h"
+#include "main.h" // For g_materials
+#include "mapnode.h" // For content_t
#define QUANTITY_ITEM_MAX_COUNT 99
+class ServerActiveObject;
+class ServerEnvironment;
+
class InventoryItem
{
public:
virtual const char* getName() const = 0;
// Shall write the name and the parameters
- virtual void serialize(std::ostream &os) = 0;
+ virtual void serialize(std::ostream &os) const = 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; }
+ // Return the name of the image for this item
+ virtual std::string getBasename() const { return ""; }
+ // Shall return an image of the item (or NULL)
+ virtual video::ITexture * getImage() const { return NULL; }
+ // Shall return an image of the item without embellishments (or NULL)
+ virtual video::ITexture * getImageRaw() const { return getImage(); }
#endif
// Shall return a text to show in the GUI
virtual std::string getText() { return ""; }
+ // Returns the string used for inventory
+ virtual std::string getItemString();
+ // Creates an object from the item, to be placed in the world.
+ virtual ServerActiveObject* createSAO(ServerEnvironment *env, u16 id, v3f pos);
+ // Gets amount of items that dropping one SAO will decrement
+ virtual u16 getDropCount() const { return getCount(); }
+
+ /*
+ Quantity methods
+ */
// Shall return true if the item can be add()ed to the other
- virtual bool addableTo(InventoryItem *other)
+ virtual bool addableTo(const InventoryItem *other) const
{
return false;
}
- /*
- Quantity methods
- */
- u16 getCount()
+ u16 getCount() const
{
return m_count;
}
{
m_count = count;
}
- virtual u16 freeSpace()
+ // This should return something else for stackable items
+ virtual u16 freeSpace() const
{
return 0;
}
m_count -= count;
}
+ /*
+ Other properties
+ */
+
+ // Whether it can be cooked
+ virtual bool isCookable() const {return false;}
+ // Time of cooking
+ virtual float getCookTime(){return 3.0;}
+ // Result of cooking (can randomize)
+ virtual InventoryItem *createCookResult() const {return NULL;}
+
+ // Eat, press, activate, whatever.
+ // Called when item is right-clicked when lying on ground.
+ // If returns true, item shall be deleted.
+ virtual bool use(ServerEnvironment *env,
+ ServerActiveObject *user){return false;}
+
protected:
u16 m_count;
};
class MaterialItem : public InventoryItem
{
public:
- MaterialItem(u8 content, u16 count):
+ MaterialItem(content_t content, u16 count):
InventoryItem(count)
{
m_content = content;
{
return "MaterialItem";
}
- virtual void serialize(std::ostream &os)
+ virtual void serialize(std::ostream &os) const
{
//os.imbue(std::locale("C"));
- os<<getName();
+ os<<"MaterialItem2";
os<<" ";
os<<(unsigned int)m_content;
os<<" ";
return new MaterialItem(m_content, m_count);
}
#ifndef SERVER
- video::ITexture * getImage()
- {
- return content_features(m_content).inventory_texture;
- return NULL;
- }
+ video::ITexture * getImage() const;
#endif
std::string getText()
{
return os.str();
}
- virtual bool addableTo(InventoryItem *other)
+ virtual bool addableTo(const InventoryItem *other) const
{
if(std::string(other->getName()) != "MaterialItem")
return false;
return false;
return true;
}
- u16 freeSpace()
+ u16 freeSpace() const
{
if(m_count > QUANTITY_ITEM_MAX_COUNT)
return 0;
return QUANTITY_ITEM_MAX_COUNT - m_count;
}
/*
- 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
+ Other properties
*/
- 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);
- }
-
-#ifndef SERVER
- video::ITexture * getImage();
-#endif
- std::string getText();
-
+ bool isCookable() const;
+ InventoryItem *createCookResult() const;
/*
Special methods
*/
- std::string getInventoryString()
+ content_t getMaterial()
{
- return m_inventorystring;
+ return m_content;
}
-
- MapBlockObject * createObject(v3f pos, f32 player_yaw, f32 player_pitch);
-
private:
- std::string m_inventorystring;
+ content_t m_content;
};
/*
{
return "CraftItem";
}
- virtual void serialize(std::ostream &os)
+ virtual void serialize(std::ostream &os) const
{
os<<getName();
os<<" ";
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);
- }
+ video::ITexture * getImage() const;
#endif
std::string getText()
{
os<<m_count;
return os.str();
}
- virtual bool addableTo(InventoryItem *other)
+
+ ServerActiveObject* createSAO(ServerEnvironment *env, u16 id, v3f pos);
+ u16 getDropCount() const;
+
+ virtual bool addableTo(const InventoryItem *other) const
{
if(std::string(other->getName()) != "CraftItem")
return false;
return false;
return true;
}
- u16 freeSpace()
+ u16 freeSpace() const
{
if(m_count > QUANTITY_ITEM_MAX_COUNT)
return 0;
return QUANTITY_ITEM_MAX_COUNT - m_count;
}
+
+ /*
+ Other properties
+ */
+
+ bool isCookable() const;
+ InventoryItem *createCookResult() const;
+
+ bool use(ServerEnvironment *env, ServerActiveObject *user);
+
/*
Special methods
*/
{
return "ToolItem";
}
- virtual void serialize(std::ostream &os)
+ virtual void serialize(std::ostream &os) const
{
os<<getName();
os<<" ";
return new ToolItem(m_toolname, m_wear);
}
#ifndef SERVER
- video::ITexture * getImage()
- {
- if(g_texturesource == NULL)
- return NULL;
-
- std::string basename;
+ std::string getBasename() const {
if(m_toolname == "WPick")
- basename = "tool_wpick.png";
+ return "tool_woodpick.png";
else if(m_toolname == "STPick")
- basename = "tool_stpick.png";
+ return "tool_stonepick.png";
+ else if(m_toolname == "SteelPick")
+ return "tool_steelpick.png";
else if(m_toolname == "MesePick")
- basename = "tool_mesepick.png";
+ return "tool_mesepick.png";
+ else if(m_toolname == "WShovel")
+ return "tool_woodshovel.png";
+ else if(m_toolname == "STShovel")
+ return "tool_stoneshovel.png";
+ else if(m_toolname == "SteelShovel")
+ return "tool_steelshovel.png";
+ else if(m_toolname == "WAxe")
+ return "tool_woodaxe.png";
+ else if(m_toolname == "STAxe")
+ return "tool_stoneaxe.png";
+ else if(m_toolname == "SteelAxe")
+ return "tool_steelaxe.png";
+ else if(m_toolname == "WSword")
+ return "tool_woodsword.png";
+ else if(m_toolname == "STSword")
+ return "tool_stonesword.png";
+ else if(m_toolname == "SteelSword")
+ return "tool_steelsword.png";
else
- basename = "cloud.png";
+ return "cloud.png";
+}
+
+ video::ITexture * getImage() const
+ {
+ if(g_texturesource == NULL)
+ return NULL;
+
+ std::string basename = getBasename();
/*
Calculate a progress value with sane amount of
os<<basename<<"^[progressbar"<<value_f;
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);*/
+ video::ITexture * getImageRaw() const
+ {
+ if(g_texturesource == NULL)
+ return NULL;
+
+ return g_texturesource->getTextureRaw(getBasename());
}
#endif
std::string getText()
InventoryList(std::string name, u32 size);
~InventoryList();
void clearItems();
- void serialize(std::ostream &os);
+ void serialize(std::ostream &os) const;
void deSerialize(std::istream &is);
InventoryList(const InventoryList &other);
InventoryList & operator = (const InventoryList &other);
- std::string getName();
+ const std::string &getName() const;
u32 getSize();
// Count used slots
u32 getUsedSlots();
+ u32 getFreeSlots();
+
+ /*bool getDirty(){ return m_dirty; }
+ void setDirty(bool dirty=true){ m_dirty = dirty; }*/
// Get pointer to item
+ const InventoryItem * getItem(u32 i) const;
InventoryItem * getItem(u32 i);
// Returns old item (or NULL). Parameter can be NULL.
InventoryItem * changeItem(u32 i, InventoryItem *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);
// If can be added fully, NULL is returned.
InventoryItem * addItem(u32 i, InventoryItem *newitem);
+ // Checks whether the item could be added to the given slot
+ bool itemFits(const u32 i, const InventoryItem *newitem);
+
+ // Checks whether there is room for a given item
+ bool roomForItem(const InventoryItem *item);
+
+ // Checks whether there is room for a given item aftr it has been cooked
+ bool roomForCookedItem(const InventoryItem *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.
core::array<InventoryItem*> m_items;
u32 m_size;
std::string m_name;
+ //bool m_dirty;
};
class Inventory
Inventory(const Inventory &other);
Inventory & operator = (const Inventory &other);
- void serialize(std::ostream &os);
+ 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;
bool deleteList(const std::string &name);
// A shorthand for adding items.
// Returns NULL if the item was fully added, leftover otherwise.
private:
// -1 if not found
- s32 getListIndex(const std::string &name);
+ const s32 getListIndex(const std::string &name) const;
core::array<InventoryList*> m_lists;
};
+class Player;
+
+struct InventoryContext
+{
+ Player *current_player;
+
+ InventoryContext():
+ current_player(NULL)
+ {}
+};
+
+struct InventoryAction;
+
+class InventoryManager
+{
+public:
+ InventoryManager(){}
+ virtual ~InventoryManager(){}
+
+ /*
+ Get a pointer to an inventory specified by id.
+ id can be:
+ - "current_player"
+ - "nodemeta:X,Y,Z"
+ */
+ virtual Inventory* getInventory(InventoryContext *c, std::string id)
+ {return NULL;}
+ // Used on the server by InventoryAction::apply and other stuff
+ virtual void inventoryModified(InventoryContext *c, std::string id)
+ {}
+ // Used on the client
+ virtual void inventoryAction(InventoryAction *a)
+ {}
+};
+
#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;
+ virtual void serialize(std::ostream &os) const = 0;
+ virtual void apply(InventoryContext *c, InventoryManager *mgr) = 0;
};
struct IMoveAction : public InventoryAction
{
// count=0 means "everything"
u16 count;
- std::string from_name;
+ std::string from_inv;
+ std::string from_list;
s16 from_i;
- std::string to_name;
+ std::string to_inv;
+ std::string to_list;
s16 to_i;
IMoveAction()
std::getline(is, ts, ' ');
count = stoi(ts);
- std::getline(is, from_name, ' ');
+ std::getline(is, from_inv, ' ');
+
+ std::getline(is, from_list, ' ');
std::getline(is, ts, ' ');
from_i = stoi(ts);
- std::getline(is, to_name, ' ');
+ std::getline(is, to_inv, ' ');
+
+ std::getline(is, to_list, ' ');
std::getline(is, ts, ' ');
to_i = stoi(ts);
return IACTION_MOVE;
}
- void serialize(std::ostream &os)
+ void serialize(std::ostream &os) const
{
os<<"Move ";
os<<count<<" ";
- os<<from_name<<" ";
+ os<<from_inv<<" ";
+ os<<from_list<<" ";
os<<from_i<<" ";
- os<<to_name<<" ";
+ os<<to_inv<<" ";
+ os<<to_list<<" ";
os<<to_i;
}
- void apply(Inventory *inventory);
+ void apply(InventoryContext *c, InventoryManager *mgr);
+};
+
+/*
+ Craft checking system
+*/
+
+enum ItemSpecType
+{
+ ITEM_NONE,
+ ITEM_MATERIAL,
+ ITEM_CRAFT,
+ ITEM_TOOL,
+ ITEM_MBO
+};
+
+struct ItemSpec
+{
+ enum ItemSpecType type;
+ // Only other one of these is used
+ std::string name;
+ u16 num;
+
+ ItemSpec():
+ type(ITEM_NONE)
+ {
+ }
+ ItemSpec(enum ItemSpecType a_type, std::string a_name):
+ type(a_type),
+ name(a_name),
+ num(65535)
+ {
+ }
+ ItemSpec(enum ItemSpecType a_type, u16 a_num):
+ type(a_type),
+ name(""),
+ num(a_num)
+ {
+ }
+
+ bool checkItem(const InventoryItem *item) const;
};
+/*
+ items: a pointer to an array of 9 pointers to items
+ specs: a pointer to an array of 9 ItemSpecs
+*/
+bool checkItemCombination(const InventoryItem * const*items, const ItemSpec *specs);
+
#endif