minetest/src/inventory.h

574 lines
11 KiB
C
Raw Normal View History

/*
Minetest-c55
Copyright (C) 2010 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
/*
(c) 2010 Perttu Ahola <celeron55@gmail.com>
*/
#ifndef INVENTORY_HEADER
#define INVENTORY_HEADER
#include <iostream>
#include <sstream>
#include <string>
#include "common_irrlicht.h"
#include "debug.h"
#include "mapblockobject.h"
// For g_materials
#include "main.h"
#define QUANTITY_ITEM_MAX_COUNT 99
2010-11-27 00:02:21 +01:00
class InventoryItem
{
public:
InventoryItem(u16 count);
2010-11-27 00:02:21 +01:00
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;
2010-12-21 17:08:24 +01:00
#ifndef SERVER
2010-11-27 00:02:21 +01:00
// Shall return an image to show in the GUI (or NULL)
virtual video::ITexture * getImage() { return NULL; }
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 ""; }
// 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;
}
2010-11-27 00:02:21 +01:00
protected:
u16 m_count;
};
2010-11-27 00:02:21 +01:00
class MaterialItem : public InventoryItem
{
public:
MaterialItem(u8 content, u16 count):
InventoryItem(count)
2010-11-27 00:02:21 +01:00
{
2010-12-14 00:56:24 +01:00
m_content = content;
2010-11-27 00:02:21 +01:00
}
/*
Implementation interface
*/
virtual const char* getName() const
{
return "MaterialItem";
}
virtual void serialize(std::ostream &os)
{
//os.imbue(std::locale("C"));
os<<getName();
os<<" ";
2010-12-14 00:56:24 +01:00
os<<(unsigned int)m_content;
2010-11-27 00:02:21 +01:00
os<<" ";
os<<m_count;
}
virtual InventoryItem* clone()
{
2010-12-14 00:56:24 +01:00
return new MaterialItem(m_content, m_count);
2010-11-27 00:02:21 +01:00
}
#ifndef SERVER
2010-11-27 00:02:21 +01:00
video::ITexture * getImage()
{
/*if(m_content >= USEFUL_CONTENT_COUNT)
2010-12-14 00:56:24 +01:00
return NULL;
return g_irrlicht->getTexture(g_content_inventory_texture_paths[m_content]);*/
return g_irrlicht->getTexture(content_features(m_content).inventory_texture);
2010-11-27 00:02:21 +01:00
}
#endif
2010-11-27 00:02:21 +01:00
std::string getText()
{
std::ostringstream os;
os<<m_count;
return os.str();
}
virtual bool addableTo(InventoryItem *other)
2010-11-27 00:02:21 +01:00
{
if(std::string(other->getName()) != "MaterialItem")
return false;
MaterialItem *m = (MaterialItem*)other;
if(m->getMaterial() != m_content)
return false;
return true;
2010-11-27 00:02:21 +01:00
}
u16 freeSpace()
{
if(m_count > QUANTITY_ITEM_MAX_COUNT)
2010-11-27 00:02:21 +01:00
return 0;
return QUANTITY_ITEM_MAX_COUNT - m_count;
2010-11-27 00:02:21 +01:00
}
/*
Special methods
*/
u8 getMaterial()
2010-11-27 00:02:21 +01:00
{
return m_content;
2010-11-27 00:02:21 +01:00
}
private:
2010-12-14 00:56:24 +01:00
u8 m_content;
2010-11-27 00:02:21 +01:00
};
class MapBlockObjectItem : public InventoryItem
{
public:
MapBlockObjectItem(std::string inventorystring):
InventoryItem(1)
2010-11-27 00:02:21 +01:00
{
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);
}
2010-12-21 17:08:24 +01:00
#ifndef SERVER
2010-11-27 00:02:21 +01:00
video::ITexture * getImage();
2010-12-21 17:08:24 +01:00
#endif
2010-11-27 00:02:21 +01:00
std::string getText();
/*
Special methods
*/
std::string getInventoryString()
{
return m_inventorystring;
}
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
{
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()
{
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);
}
#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;
};
2010-12-24 02:08:05 +01:00
class ToolItem : public InventoryItem
{
public:
ToolItem(std::string toolname, u16 wear):
InventoryItem(1)
2010-12-24 02:08:05 +01:00
{
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()
{
2010-12-24 10:44:26 +01:00
std::string basename;
2010-12-24 02:08:05 +01:00
if(m_toolname == "WPick")
basename = "tool_wpick.png";
2010-12-24 10:44:26 +01:00
else if(m_toolname == "STPick")
basename = "tool_stpick.png";
2010-12-25 01:33:41 +01:00
else if(m_toolname == "MesePick")
basename = "tool_mesepick.png";
2010-12-24 10:44:26 +01:00
else
basename = "cloud.png";
2010-12-24 10:44:26 +01:00
/*
Calculate a progress value with sane amount of
2010-12-24 10:44:26 +01:00
maximum states
*/
u32 maxprogress = 30;
u32 toolprogress = (65535-m_wear)/(65535/maxprogress);
float value_f = (float)toolprogress / (float)maxprogress;
std::ostringstream os;
os<<"[progressbar"<<value_f;
TextureSpec spec;
spec.addTid(g_irrlicht->getTextureId(basename));
spec.addTid(g_irrlicht->getTextureId(os.str()));
return g_irrlicht->getTexture(spec);
/*// Make texture name for the new texture with a progress bar
float value_f = (float)toolprogress / (float)maxprogress;
std::ostringstream os;
os<<basename<<"[[mod:progressbar"<<value_f;
return g_irrlicht->getTexture(os.str());*/
/*// Make texture name for the new texture with a progress bar
2010-12-24 10:44:26 +01:00
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));*/
2010-12-24 02:08:05 +01:00
}
#endif
std::string getText()
{
2010-12-24 10:44:26 +01:00
return "";
/*std::ostringstream os;
2010-12-24 02:08:05 +01:00
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<<'-';
2010-12-24 10:44:26 +01:00
return os.str();*/
2010-12-24 02:08:05 +01:00
/*std::ostringstream os;
os<<m_toolname;
os<<" ";
os<<(m_wear/655);
return os.str();*/
}
/*
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();
void serialize(std::ostream &os);
void deSerialize(std::istream &is);
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
2010-12-22 10:29:06 +01:00
std::string getName();
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();
2010-12-22 15:30:23 +01:00
// Get pointer to item
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);
// 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);
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;
};
class Inventory
{
public:
~Inventory();
void clear();
Inventory();
Inventory(const Inventory &other);
Inventory & operator = (const Inventory &other);
void serialize(std::ostream &os);
void deSerialize(std::istream &is);
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.
// 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
s32 getListIndex(const std::string &name);
core::array<InventoryList*> m_lists;
2010-11-27 00:02:21 +01:00
};
2010-12-22 15:30:23 +01:00
#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"
2010-12-22 15:30:23 +01:00
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;
}
void apply(Inventory *inventory);
};
2010-11-27 00:02:21 +01:00
#endif