51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#ifndef INVENTORY_HEADER
-#define INVENTORY_HEADER
+#pragma once
-#include <iostream>
-#include <sstream>
+#include "itemdef.h"
+#include "irrlichttypes.h"
+#include "itemstackmetadata.h"
+#include <istream>
+#include <ostream>
#include <string>
#include <vector>
-#include "irrlichttypes_bloated.h"
-#include "debug.h"
-#include "itemdef.h"
+#include <cassert>
struct ToolCapabilities;
struct ItemStack
{
- ItemStack(): name(""), count(0), wear(0), metadata("") {}
- ItemStack(std::string name_, u16 count_,
- u16 wear, std::string metadata_,
- IItemDefManager *itemdef);
- ~ItemStack() {}
+ ItemStack() = default;
+
+ ItemStack(const std::string &name_, u16 count_,
+ u16 wear, IItemDefManager *itemdef);
+
+ ~ItemStack() = default;
// Serialization
- void serialize(std::ostream &os) const;
- void deSerialize(std::istream &is, IItemDefManager *itemdef);
- void deSerialize(const std::string &s, IItemDefManager *itemdef);
+ void serialize(std::ostream &os, bool serialize_meta = true) const;
+ // Deserialization. Pass itemdef unless you don't want aliases resolved.
+ void deSerialize(std::istream &is, IItemDefManager *itemdef = NULL);
+ void deSerialize(const std::string &s, IItemDefManager *itemdef = NULL);
// Returns the string used for inventory
- std::string getItemString() const;
+ std::string getItemString(bool include_meta = true) const;
+ // Returns the tooltip
+ std::string getDescription(IItemDefManager *itemdef) const;
/*
Quantity methods
name = "";
count = 0;
wear = 0;
- metadata = "";
+ metadata.clear();
}
void add(u16 n)
void remove(u16 n)
{
- assert(count >= n);
+ assert(count >= n); // Pre-condition
count -= n;
if(count == 0)
clear(); // reset name, wear and metadata too
// Maximum size of a stack
u16 getStackMax(IItemDefManager *itemdef) const
{
- s16 max = itemdef->get(name).stack_max;
- return (max >= 0) ? max : 0;
+ return itemdef->get(name).stack_max;
}
// Number of items that can be added to this stack
u16 freeSpace(IItemDefManager *itemdef) const
{
u16 max = getStackMax(itemdef);
- if(count > max)
+ if (count >= max)
return 0;
return max - count;
}
const ToolCapabilities& getToolCapabilities(
IItemDefManager *itemdef) const
{
- ToolCapabilities *cap;
- cap = itemdef->get(name).tool_capabilities;
- if(cap == NULL)
- cap = itemdef->get("").tool_capabilities;
- assert(cap != NULL);
- return *cap;
+ const ToolCapabilities *item_cap =
+ itemdef->get(name).tool_capabilities;
+
+ if (item_cap == NULL)
+ // Fall back to the hand's tool capabilities
+ item_cap = itemdef->get("").tool_capabilities;
+
+ assert(item_cap != NULL);
+ return metadata.getToolCapabilities(*item_cap); // Check for override
}
// Wear out (only tools)
wear += amount;
return true;
}
- else
- {
- return false;
- }
+
+ return false;
}
// 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);
+ ItemStack addItem(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,
+ bool itemFits(ItemStack newitem,
ItemStack *restitem, // may be NULL
IItemDefManager *itemdef) const;
// Similar to takeItem, but keeps this ItemStack intact.
ItemStack peekItem(u32 peekcount) const;
+ bool operator ==(const ItemStack &s) const
+ {
+ return (this->name == s.name &&
+ this->count == s.count &&
+ this->wear == s.wear &&
+ this->metadata == s.metadata);
+ }
+
+ bool operator !=(const ItemStack &s) const
+ {
+ return !(*this == s);
+ }
+
/*
Properties
*/
- std::string name;
- u16 count;
- u16 wear;
- std::string metadata;
+ std::string name = "";
+ u16 count = 0;
+ u16 wear = 0;
+ ItemStackMetadata metadata;
};
class InventoryList
{
public:
- InventoryList(std::string name, u32 size, IItemDefManager *itemdef);
- ~InventoryList();
+ InventoryList(const std::string &name, u32 size, IItemDefManager *itemdef);
+ ~InventoryList() = default;
void clearItems();
void setSize(u32 newsize);
void setWidth(u32 newWidth);
void setName(const std::string &name);
- void serialize(std::ostream &os) const;
+ void serialize(std::ostream &os, bool incremental) const;
void deSerialize(std::istream &is);
InventoryList(const InventoryList &other);
InventoryList & operator = (const InventoryList &other);
+ bool operator == (const InventoryList &other) const;
+ bool operator != (const InventoryList &other) const
+ {
+ return !(*this == other);
+ }
const std::string &getName() const;
u32 getSize() 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
+ // Checks whether the given count of the given item
// exists in this inventory list.
- bool containsItem(const ItemStack &item) const;
+ // If match_meta is false, only the items' names are compared.
+ bool containsItem(const ItemStack &item, bool match_meta) const;
// Removes the given count of the given item name from
// this inventory list. Walks the list in reverse order.
// 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);
+ // returns number of moved items
+ u32 moveItem(u32 i, InventoryList *dest, u32 dest_i,
+ u32 count = 0, bool swap_if_needed = true, bool *did_swap = NULL);
+
+ // like moveItem, but without a fixed destination index
+ // also with optional rollback recording
+ void moveItemSomewhere(u32 i, InventoryList *dest, u32 count);
+
+ inline bool checkModified() const { return m_dirty; }
+ inline void setModified(bool dirty = true) { m_dirty = dirty; }
private:
std::vector<ItemStack> m_items;
- u32 m_size, m_width;
std::string m_name;
+ u32 m_size;
+ u32 m_width = 0;
IItemDefManager *m_itemdef;
+ bool m_dirty = true;
};
class Inventory
~Inventory();
void clear();
- void clearContents();
Inventory(IItemDefManager *itemdef);
Inventory(const Inventory &other);
Inventory & operator = (const Inventory &other);
-
- void serialize(std::ostream &os) const;
+ bool operator == (const Inventory &other) const;
+ bool operator != (const Inventory &other) const
+ {
+ return !(*this == other);
+ }
+
+ // Never ever serialize to disk using "incremental"!
+ void serialize(std::ostream &os, bool incremental = false) const;
void deSerialize(std::istream &is);
InventoryList * addList(const std::string &name, u32 size);
return newitem;
return list->addItem(newitem);
}
-
+
+ inline bool checkModified() const
+ {
+ if (m_dirty)
+ return true;
+
+ for (const auto &list : m_lists)
+ if (list->checkModified())
+ return true;
+
+ return false;
+ }
+
+ inline void setModified(bool dirty = true)
+ {
+ m_dirty = dirty;
+ // Set all as handled
+ if (!dirty) {
+ for (const auto &list : m_lists)
+ list->setModified(dirty);
+ }
+ }
private:
// -1 if not found
const s32 getListIndex(const std::string &name) const;
std::vector<InventoryList*> m_lists;
IItemDefManager *m_itemdef;
+ bool m_dirty = true;
};
-
-#endif
-
projects / oweals / minetest.git / blobdiff