minetest/src/inventory.h

696 lines
15 KiB
C
Raw Normal View History

/*
Minetest-c55
Copyright (C) 2010-2011 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
(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.
You should have received a copy of the GNU 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.
*/
2010-11-27 00:02:21 +01:00
#ifndef INVENTORY_HEADER
#define INVENTORY_HEADER
#include <iostream>
#include <sstream>
#include <string>
#include "common_irrlicht.h"
#include "debug.h"
2011-07-23 15:55:26 +02:00
#include "mapnode.h" // For content_t
2010-11-27 00:02:21 +01:00
#define QUANTITY_ITEM_MAX_COUNT 99
class ServerActiveObject;
class ServerEnvironment;
struct PointedThing;
class ITextureSource;
class IGameDef;
2010-11-27 00:02:21 +01:00
class InventoryItem
{
public:
InventoryItem(IGameDef *gamedef, u16 count);
2010-11-27 00:02:21 +01:00
virtual ~InventoryItem();
static InventoryItem* deSerialize(std::istream &is, IGameDef *gamedef);
2011-11-28 13:55:24 +01:00
static InventoryItem* deSerialize(const std::string &str,
IGameDef *gamedef);
2010-11-27 00:02:21 +01:00
virtual const char* getName() const = 0;
// Shall write the name and the parameters
2011-08-10 23:22:44 +02:00
virtual void serialize(std::ostream &os) const = 0;
2010-11-27 00:02:21 +01:00
// Shall make an exact clone of the item
virtual InventoryItem* clone() = 0;
// Return the name of the image for this item
2011-11-13 15:38:14 +01:00
virtual std::string getImageBasename() const { return ""; }
#ifndef SERVER
// Shall return an image of the item (or NULL)
2011-11-16 13:44:01 +01:00
virtual video::ITexture * getImage() const
{ return NULL; }
// Shall return an image of the item without embellishments (or NULL)
2011-11-16 13:44:01 +01:00
virtual video::ITexture * getImageRaw() const
{ return getImage(); }
2010-12-21 17:08:24 +01:00
#endif
2010-11-27 00:02:21 +01:00
// Shall return a text to show in the GUI
virtual std::string getText() { return ""; }
// Returns the string used for inventory
virtual std::string getItemString();
/*
Quantity methods
*/
2010-11-27 00:02:21 +01:00
2011-11-17 01:28:46 +01:00
// Return true if the item can be add()ed to the other
2011-08-10 11:38:49 +02:00
virtual bool addableTo(const InventoryItem *other) const
2011-11-17 01:28:46 +01:00
{ return false; }
// Return true if the other item contains this item
virtual bool isSubsetOf(const InventoryItem *other) const
{ return false; }
// Remove the other item from this one if possible and return true
// Return false if not possible
virtual bool removeOther(const InventoryItem *other)
{ return false; }
2011-08-10 11:38:49 +02:00
u16 getCount() const
2011-11-17 01:28:46 +01:00
{ return m_count; }
void setCount(u16 count)
2011-11-17 01:28:46 +01:00
{ m_count = count; }
2011-11-29 16:15:18 +01:00
u16 freeSpace() const
{
u16 max = getStackMax();
if(m_count > max)
return 0;
return max - m_count;
}
2011-11-17 01:28:46 +01:00
void add(u16 count)
{
m_count += count;
}
void remove(u16 count)
{
assert(m_count >= count);
m_count -= count;
}
2010-11-27 00:02:21 +01:00
2011-04-05 09:59:48 +02:00
/*
Other properties
*/
2011-11-29 16:15:18 +01:00
// Maximum size of a stack
virtual u16 getStackMax() const {return 1;}
// Whether it can be used
virtual bool isUsable() const {return false;}
// Whether it can be cooked
2011-08-10 11:38:49 +02:00
virtual bool isCookable() const {return false;}
// Result of cooking (can randomize)
2011-08-10 11:38:49 +02:00
virtual InventoryItem *createCookResult() const {return NULL;}
// Time of cooking
virtual float getCookTime() const {return 3.0;}
// Whether it can be burned (<0 = cannot be burned)
virtual float getBurnTime() const {return -1;}
2011-11-29 16:15:18 +01:00
// Gets amount of items that dropping one ItemSAO will decrement
// -1 means as many as possible
virtual s16 getDropCount() const { return -1; }
// Whether this item can point to liquids
virtual bool areLiquidsPointable() const { return false; }
// Creates an object from the item and places it in the world.
// If return value is true, item should be removed.
virtual bool dropOrPlace(ServerEnvironment *env,
ServerActiveObject *dropper,
v3f pos, bool place, s16 count);
// Eat, press, activate, whatever.
2011-11-29 16:15:18 +01:00
// Called when item is left-clicked while in hand.
// If returns true, item shall be deleted.
virtual bool use(ServerEnvironment *env,
2011-11-29 16:15:18 +01:00
ServerActiveObject *user,
const PointedThing& pointed){return false;}
2011-04-05 09:59:48 +02:00
protected:
IGameDef *m_gamedef;
u16 m_count;
};
2010-11-27 00:02:21 +01:00
class MaterialItem : public InventoryItem
{
public:
MaterialItem(IGameDef *gamedef, std::string nodename, u16 count);
// Legacy constructor
MaterialItem(IGameDef *gamedef, content_t content, u16 count);
2010-11-27 00:02:21 +01:00
/*
Implementation interface
*/
virtual const char* getName() const
{
return "MaterialItem";
}
2011-08-10 23:22:44 +02:00
virtual void serialize(std::ostream &os) const
2010-11-27 00:02:21 +01:00
{
2011-11-16 21:47:37 +01:00
os<<"NodeItem";
os<<" \"";
2011-11-16 21:47:37 +01:00
os<<m_nodename;
os<<"\" ";
os<<m_count;
2010-11-27 00:02:21 +01:00
}
virtual InventoryItem* clone()
{
return new MaterialItem(m_gamedef, m_nodename, m_count);
2010-11-27 00:02:21 +01:00
}
#ifndef SERVER
2011-11-16 13:44:01 +01:00
video::ITexture * getImage() const;
#endif
2010-11-27 00:02:21 +01:00
std::string getText()
{
std::ostringstream os;
os<<m_count;
return os.str();
}
2011-08-10 11:38:49 +02:00
virtual bool addableTo(const InventoryItem *other) const
2010-11-27 00:02:21 +01:00
{
if(std::string(other->getName()) != "MaterialItem")
return false;
MaterialItem *m = (MaterialItem*)other;
if(m->m_nodename != m_nodename)
return false;
return true;
2010-11-27 00:02:21 +01:00
}
2011-11-17 01:28:46 +01:00
virtual bool isSubsetOf(const InventoryItem *other) const
{
if(std::string(other->getName()) != "MaterialItem")
return false;
MaterialItem *m = (MaterialItem*)other;
if(m->m_nodename != m_nodename)
return false;
return m_count <= m->m_count;
}
virtual bool removeOther(const InventoryItem *other)
{
if(!other->isSubsetOf(this))
return false;
MaterialItem *m = (MaterialItem*)other;
m_count += m->m_count;
return true;
}
2011-11-29 16:15:18 +01:00
u16 getStackMax() const
2010-11-27 00:02:21 +01:00
{
2011-11-29 16:15:18 +01:00
return QUANTITY_ITEM_MAX_COUNT;
2010-11-27 00:02:21 +01:00
}
2011-11-29 16:15:18 +01:00
2011-04-05 09:59:48 +02:00
/*
Other properties
*/
2011-08-10 11:38:49 +02:00
bool isCookable() const;
InventoryItem *createCookResult() const;
float getCookTime() const;
float getBurnTime() const;
/*
Special properties (not part of virtual interface)
*/
std::string getNodeName() const
{ return m_nodename; }
content_t getMaterial() const;
2010-11-27 00:02:21 +01:00
private:
std::string m_nodename;
2010-11-27 00:02:21 +01:00
};
/*
An item that is used as a mid-product when crafting.
Subnames:
- Stick
*/
class CraftItem : public InventoryItem
{
public:
CraftItem(IGameDef *gamedef, std::string subname, u16 count):
InventoryItem(gamedef, count)
{
m_subname = subname;
}
/*
Implementation interface
*/
virtual const char* getName() const
{
return "CraftItem";
}
2011-08-10 23:22:44 +02:00
virtual void serialize(std::ostream &os) const
{
os<<getName();
2011-11-16 21:47:37 +01:00
os<<" \"";
os<<m_subname;
2011-11-16 21:47:37 +01:00
os<<"\" ";
os<<m_count;
}
virtual InventoryItem* clone()
{
return new CraftItem(m_gamedef, m_subname, m_count);
}
#ifndef SERVER
2011-11-16 13:44:01 +01:00
video::ITexture * getImage() const;
#endif
std::string getText()
{
std::ostringstream os;
os<<m_count;
return os.str();
}
2011-08-10 11:38:49 +02:00
virtual bool addableTo(const InventoryItem *other) const
{
if(std::string(other->getName()) != "CraftItem")
return false;
CraftItem *m = (CraftItem*)other;
if(m->m_subname != m_subname)
return false;
return true;
}
2011-11-17 01:28:46 +01:00
virtual bool isSubsetOf(const InventoryItem *other) const
{
if(std::string(other->getName()) != "CraftItem")
return false;
CraftItem *m = (CraftItem*)other;
if(m->m_subname != m_subname)
return false;
return m_count <= m->m_count;
}
virtual bool removeOther(const InventoryItem *other)
{
if(!other->isSubsetOf(this))
return false;
CraftItem *m = (CraftItem*)other;
m_count += m->m_count;
return true;
}
/*
Other properties
*/
2011-11-29 16:15:18 +01:00
u16 getStackMax() const;
bool isUsable() const;
2011-08-10 11:38:49 +02:00
bool isCookable() const;
InventoryItem *createCookResult() const;
float getCookTime() const;
float getBurnTime() const;
2011-11-29 16:15:18 +01:00
s16 getDropCount() const;
bool areLiquidsPointable() const;
bool dropOrPlace(ServerEnvironment *env,
ServerActiveObject *dropper,
v3f pos, bool place, s16 count);
bool use(ServerEnvironment *env,
ServerActiveObject *user,
const PointedThing& pointed);
/*
Special methods
*/
std::string getSubName()
{
return m_subname;
}
private:
std::string m_subname;
};
2010-12-24 02:08:05 +01:00
class ToolItem : public InventoryItem
{
public:
ToolItem(IGameDef *gamedef, std::string toolname, u16 wear):
InventoryItem(gamedef, 1)
2010-12-24 02:08:05 +01:00
{
m_toolname = toolname;
m_wear = wear;
}
/*
Implementation interface
*/
virtual const char* getName() const
{
return "ToolItem";
}
2011-08-10 23:22:44 +02:00
virtual void serialize(std::ostream &os) const
2010-12-24 02:08:05 +01:00
{
os<<getName();
2011-11-16 21:47:37 +01:00
os<<" \"";
2010-12-24 02:08:05 +01:00
os<<m_toolname;
2011-11-16 21:47:37 +01:00
os<<"\" ";
2010-12-24 02:08:05 +01:00
os<<m_wear;
}
virtual InventoryItem* clone()
{
return new ToolItem(m_gamedef, m_toolname, m_wear);
2010-12-24 02:08:05 +01:00
}
2011-11-13 15:38:14 +01:00
std::string getImageBasename() const;
2010-12-24 02:08:05 +01:00
#ifndef SERVER
2011-11-16 13:44:01 +01:00
video::ITexture * getImage() const;
video::ITexture * getImageRaw() const;
2010-12-24 02:08:05 +01:00
#endif
2010-12-24 02:08:05 +01:00
std::string getText()
{
2010-12-24 10:44:26 +01:00
return "";
2010-12-24 02:08:05 +01:00
}
2011-11-17 01:28:46 +01:00
virtual bool isSubsetOf(const InventoryItem *other) const
{
if(std::string(other->getName()) != "ToolItem")
return false;
ToolItem *m = (ToolItem*)other;
if(m->m_toolname != m_toolname)
return false;
return m_wear <= m->m_wear;
}
virtual bool removeOther(const InventoryItem *other)
{
if(!other->isSubsetOf(this))
return false;
ToolItem *m = (ToolItem*)other;
m_wear -= m->m_wear;
return true;
}
2010-12-24 02:08:05 +01:00
/*
Special methods
*/
std::string getToolName()
{
return m_toolname;
}
u16 getWear()
{
return m_wear;
}
2010-12-25 00:54:39 +01:00
// 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;
}
}
2010-12-24 02:08:05 +01:00
private:
std::string m_toolname;
u16 m_wear;
};
2010-12-22 10:29:06 +01:00
class InventoryList
2010-11-27 00:02:21 +01:00
{
public:
2010-12-22 10:29:06 +01:00
InventoryList(std::string name, u32 size);
~InventoryList();
2010-11-27 00:02:21 +01:00
void clearItems();
2011-08-10 23:22:44 +02:00
void serialize(std::ostream &os) const;
void deSerialize(std::istream &is, IGameDef *gamedef);
2010-11-27 00:02:21 +01:00
2010-12-22 10:29:06 +01:00
InventoryList(const InventoryList &other);
InventoryList & operator = (const InventoryList &other);
2010-11-27 00:02:21 +01:00
2011-08-10 11:38:49 +02:00
const std::string &getName() const;
2010-11-27 00:02:21 +01:00
u32 getSize();
2010-12-22 10:29:06 +01:00
// Count used slots
2010-11-27 00:02:21 +01:00
u32 getUsedSlots();
2011-04-05 09:59:48 +02:00
u32 getFreeSlots();
/*bool getDirty(){ return m_dirty; }
void setDirty(bool dirty=true){ m_dirty = dirty; }*/
2010-11-27 00:02:21 +01:00
2010-12-22 15:30:23 +01:00
// Get pointer to item
2011-08-10 11:38:49 +02:00
const InventoryItem * getItem(u32 i) const;
2010-11-27 00:02:21 +01:00
InventoryItem * getItem(u32 i);
// Returns old item (or NULL). Parameter can be NULL.
InventoryItem * changeItem(u32 i, InventoryItem *newitem);
2010-12-22 15:30:23 +01:00
// Delete item
2010-11-27 00:02:21 +01:00
void deleteItem(u32 i);
2011-04-05 01:56:29 +02:00
// 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);
2011-04-05 01:56:29 +02:00
// 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);
2011-04-05 01:56:29 +02:00
// 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);
2010-12-22 15:30:23 +01:00
// Decrements amount of every material item
void decrementMaterials(u16 count);
2010-11-27 00:02:21 +01:00
void print(std::ostream &o);
private:
core::array<InventoryItem*> m_items;
u32 m_size;
2010-12-22 10:29:06 +01:00
std::string m_name;
//bool m_dirty;
2010-12-22 10:29:06 +01:00
};
class Inventory
{
public:
~Inventory();
void clear();
Inventory();
Inventory(const Inventory &other);
Inventory & operator = (const Inventory &other);
2011-08-10 23:22:44 +02:00
void serialize(std::ostream &os) const;
void deSerialize(std::istream &is, IGameDef *gamedef);
2010-12-22 10:29:06 +01:00
InventoryList * addList(const std::string &name, u32 size);
InventoryList * getList(const std::string &name);
2011-08-10 11:38:49 +02:00
const InventoryList * getList(const std::string &name) const;
2010-12-22 10:29:06 +01:00
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)
2010-12-22 10:29:06 +01:00
{
InventoryList *list = getList(listname);
if(list == NULL)
return newitem;
2010-12-22 10:29:06 +01:00
return list->addItem(newitem);
}
private:
// -1 if not found
2011-08-10 11:38:49 +02:00
const s32 getListIndex(const std::string &name) const;
2010-12-22 10:29:06 +01:00
core::array<InventoryList*> m_lists;
2010-11-27 00:02:21 +01:00
};
2011-04-04 14:13:19 +02:00
class Player;
struct InventoryContext
{
Player *current_player;
InventoryContext():
current_player(NULL)
{}
};
struct InventoryAction;
2011-04-04 14:13:19 +02:00
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;}
2011-04-05 01:56:29 +02:00
// Used on the server by InventoryAction::apply and other stuff
2011-04-04 14:13:19 +02:00
virtual void inventoryModified(InventoryContext *c, std::string id)
{}
// Used on the client
virtual void inventoryAction(InventoryAction *a)
{}
};
2010-12-22 15:30:23 +01:00
#define IACTION_MOVE 0
2011-11-27 04:01:38 +01:00
#define IACTION_DROP 1
2010-12-22 15:30:23 +01:00
struct InventoryAction
{
static InventoryAction * deSerialize(std::istream &is);
virtual u16 getType() const = 0;
2011-08-10 23:22:44 +02:00
virtual void serialize(std::ostream &os) const = 0;
2011-11-27 04:01:38 +01:00
virtual void apply(InventoryContext *c, InventoryManager *mgr,
ServerEnvironment *env) = 0;
2010-12-22 15:30:23 +01:00
};
struct IMoveAction : public InventoryAction
{
// count=0 means "everything"
2010-12-22 15:30:23 +01:00
u16 count;
2011-04-04 14:13:19 +02:00
std::string from_inv;
std::string from_list;
2010-12-22 15:30:23 +01:00
s16 from_i;
2011-04-04 14:13:19 +02:00
std::string to_inv;
std::string to_list;
2010-12-22 15:30:23 +01:00
s16 to_i;
IMoveAction()
{
count = 0;
from_i = -1;
to_i = -1;
}
IMoveAction(std::istream &is);
2010-12-22 15:30:23 +01:00
u16 getType() const
{
return IACTION_MOVE;
}
2011-08-10 23:22:44 +02:00
void serialize(std::ostream &os) const
2010-12-22 15:30:23 +01:00
{
os<<"Move ";
os<<count<<" ";
2011-04-04 14:13:19 +02:00
os<<from_inv<<" ";
os<<from_list<<" ";
2010-12-22 15:30:23 +01:00
os<<from_i<<" ";
2011-04-04 14:13:19 +02:00
os<<to_inv<<" ";
os<<to_list<<" ";
2010-12-22 15:30:23 +01:00
os<<to_i;
}
2011-11-27 04:01:38 +01:00
void apply(InventoryContext *c, InventoryManager *mgr,
ServerEnvironment *env);
};
struct IDropAction : public InventoryAction
{
// count=0 means "everything"
u16 count;
std::string from_inv;
std::string from_list;
s16 from_i;
IDropAction()
{
count = 0;
from_i = -1;
}
IDropAction(std::istream &is);
u16 getType() const
{
return IACTION_DROP;
}
void serialize(std::ostream &os) const
{
os<<"Drop ";
os<<count<<" ";
os<<from_inv<<" ";
os<<from_list<<" ";
os<<from_i;
}
void apply(InventoryContext *c, InventoryManager *mgr,
ServerEnvironment *env);
2010-12-22 15:30:23 +01:00
};
2011-04-05 01:56:29 +02:00
/*
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)
{
}
2011-08-10 11:38:49 +02:00
bool checkItem(const InventoryItem *item) const;
2011-04-05 01:56:29 +02:00
};
/*
items: a pointer to an array of 9 pointers to items
specs: a pointer to an array of 9 ItemSpecs
*/
2011-08-10 11:38:49 +02:00
bool checkItemCombination(const InventoryItem * const*items, const ItemSpec *specs);
2011-04-05 01:56:29 +02:00
2011-11-17 01:28:46 +01:00
/*
items: a pointer to an array of 9 pointers to items
specs: a pointer to an array of 9 pointers to items
*/
bool checkItemCombination(const InventoryItem * const * items,
const InventoryItem * const * specs);
2010-11-27 00:02:21 +01:00
#endif