The huge item definition and item namespace unification patch (itemdef), see http://c55.me/minetest/wiki/doku.php?id=changes:itemdef

1 files changed, 307 insertions, 42 deletions

diff --git a/src/craftdef.h b/src/craftdef.h
index cfd58ad10..57f26f049 100644
--- a/src/craftdef.h
+++ b/src/craftdef.h
@@ -23,71 +23,328 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <string>
 #include <iostream>
 #include <vector>
-class IGameDef;
-class InventoryItem;
+#include <utility>
+#include "gamedef.h"
+#include "inventory.h"
 
-struct CraftPointerInput
+/*
+	Crafting methods.
+
+	The crafting method depends on the inventory list
+	that the crafting input comes from.
+*/
+enum CraftMethod
+{
+	// Crafting grid
+	CRAFT_METHOD_NORMAL,
+	// Cooking something in a furnace
+	CRAFT_METHOD_COOKING,
+	// Using something as fuel for a furnace
+	CRAFT_METHOD_FUEL,
+};
+
+/*
+	Input: The contents of the crafting slots, arranged in matrix form
+*/
+struct CraftInput
 {
+	CraftMethod method;
 	unsigned int width;
-	std::vector<InventoryItem*> items;
+	std::vector<ItemStack> items;
 
-	CraftPointerInput(unsigned int width_, const std::vector<InventoryItem*> &items_):
-		width(width_),
-		items(items_)
+	CraftInput():
+		method(CRAFT_METHOD_NORMAL), width(0), items()
 	{}
-	CraftPointerInput():
-		width(0)
+	CraftInput(CraftMethod method_, unsigned int width_,
+			const std::vector<ItemStack> &items_):
+		method(method_), width(width_), items(items_)
 	{}
-	~CraftPointerInput();
-	unsigned int height() const{
-		return (items.size() + width - 1) / width;
-	}
+	std::string dump() const;
 };
 
-struct CraftInput
+/*
+	Output: Result of crafting operation
+*/
+struct CraftOutput
 {
-	unsigned int width;
-	std::vector<std::string> items;
+	// Used for normal crafting and cooking, itemstring
+	std::string item;
+	// Used for cooking (cook time) and fuel (burn time), seconds
+	float time;
 
-	CraftInput(unsigned int width_, const std::vector<std::string> &items_):
-		width(width_),
-		items(items_)
+	CraftOutput():
+		item(""), time(0)
 	{}
-	CraftInput():
-		width(0)
+	CraftOutput(std::string item_, float time_):
+		item(item_), time(time_)
 	{}
-	unsigned int height() const{
-		return (items.size() + width - 1) / width;
-	}
 	std::string dump() const;
 };
 
-struct CraftDefinition
+/*
+	A list of replacements. A replacement indicates that a specific
+	input item should not be deleted (when crafting) but replaced with
+	a different item. Each replacements is a pair (itemstring to remove,
+	itemstring to replace with)
+
+	Example: If ("bucket:bucket_water", "bucket:bucket_empty") is a
+	replacement pair, the crafting input slot that contained a water
+	bucket will contain an empty bucket after crafting.
+
+	Note: replacements only work correctly when stack_max of the item
+	to be replaced is 1. It is up to the mod writer to ensure this.
+*/
+struct CraftReplacements
 {
-	std::string output;
-	CraftInput input;
+	// List of replacements
+	std::vector<std::pair<std::string, std::string> > pairs;
 
-	CraftDefinition(){}
-	CraftDefinition(const std::string &output_, unsigned int width_,
-			const std::vector<std::string> &input_):
-		output(output_),
-		input(width_, input_)
+	CraftReplacements():
+		pairs()
+	{}
+	CraftReplacements(std::vector<std::pair<std::string, std::string> > pairs_):
+		pairs(pairs_)
 	{}
-	
 	std::string dump() const;
+};
+
+/*
+	Crafting definition base class
+*/
+class CraftDefinition
+{
+public:
+	CraftDefinition(){}
+	virtual ~CraftDefinition(){}
+
 	void serialize(std::ostream &os) const;
-	void deSerialize(std::istream &is);
+	static CraftDefinition* deSerialize(std::istream &is);
+
+	// Returns type of crafting definition
+	virtual std::string getName() const=0;
+
+	// Checks whether the recipe is applicable
+	virtual bool check(const CraftInput &input, IGameDef *gamedef) const=0;
+	// Returns the output structure, meaning depends on crafting method
+	// The implementation can assume that check(input) returns true
+	virtual CraftOutput getOutput(const CraftInput &input, IGameDef *gamedef) const=0;
+	// Decreases count of every input item
+	virtual void decrementInput(CraftInput &input, IGameDef *gamedef) const=0;
+
+	virtual std::string dump() const=0;
+
+protected:
+	virtual void serializeBody(std::ostream &os) const=0;
+	virtual void deSerializeBody(std::istream &is, int version)=0;
+};
+
+/*
+	A plain-jane (shaped) crafting definition
+
+	Supported crafting method: CRAFT_METHOD_NORMAL.
+	Requires the input items to be arranged exactly like in the recipe.
+*/
+class CraftDefinitionShaped: public CraftDefinition
+{
+public:
+	CraftDefinitionShaped():
+		output(""), width(1), recipe(), replacements()
+	{}
+	CraftDefinitionShaped(
+			const std::string &output_,
+			unsigned int width_,
+			const std::vector<std::string> &recipe_,
+			const CraftReplacements &replacements_):
+		output(output_), width(width_), recipe(recipe_), replacements(replacements_)
+	{}
+	virtual ~CraftDefinitionShaped(){}
+
+	virtual std::string getName() const;
+	virtual bool check(const CraftInput &input, IGameDef *gamedef) const;
+	virtual CraftOutput getOutput(const CraftInput &input, IGameDef *gamedef) const;
+	virtual void decrementInput(CraftInput &input, IGameDef *gamedef) const;
+
+	virtual std::string dump() const;
+
+protected:
+	virtual void serializeBody(std::ostream &os) const;
+	virtual void deSerializeBody(std::istream &is, int version);
+
+private:
+	// Output itemstring
+	std::string output;
+	// Width of recipe
+	unsigned int width;
+	// Recipe matrix (itemstrings)
+	std::vector<std::string> recipe;
+	// Replacement items for decrementInput()
+	CraftReplacements replacements;
+};
+
+/*
+	A shapeless crafting definition
+	Supported crafting method: CRAFT_METHOD_NORMAL.
+	Input items can arranged in any way.
+*/
+class CraftDefinitionShapeless: public CraftDefinition
+{
+public:
+	CraftDefinitionShapeless():
+		output(""), recipe(), replacements()
+	{}
+	CraftDefinitionShapeless(
+			const std::string &output_,
+			const std::vector<std::string> &recipe_,
+			const CraftReplacements &replacements_):
+		output(output_), recipe(recipe_), replacements(replacements_)
+	{}
+	virtual ~CraftDefinitionShapeless(){}
+
+	virtual std::string getName() const;
+	virtual bool check(const CraftInput &input, IGameDef *gamedef) const;
+	virtual CraftOutput getOutput(const CraftInput &input, IGameDef *gamedef) const;
+	virtual void decrementInput(CraftInput &input, IGameDef *gamedef) const;
+
+	virtual std::string dump() const;
+
+protected:
+	virtual void serializeBody(std::ostream &os) const;
+	virtual void deSerializeBody(std::istream &is, int version);
+
+private:
+	// Output itemstring
+	std::string output;
+	// Recipe list (itemstrings)
+	std::vector<std::string> recipe;
+	// Replacement items for decrementInput()
+	CraftReplacements replacements;
+};
+
+/*
+	Tool repair crafting definition
+	Supported crafting method: CRAFT_METHOD_NORMAL.
+	Put two damaged tools into the crafting grid, get one tool back.
+	There should only be one crafting definition of this type.
+*/
+class CraftDefinitionToolRepair: public CraftDefinition
+{
+public:
+	CraftDefinitionToolRepair():
+		additional_wear(0)
+	{}
+	CraftDefinitionToolRepair(float additional_wear_):
+		additional_wear(additional_wear_)
+	{}
+	virtual ~CraftDefinitionToolRepair(){}
+
+	virtual std::string getName() const;
+	virtual bool check(const CraftInput &input, IGameDef *gamedef) const;
+	virtual CraftOutput getOutput(const CraftInput &input, IGameDef *gamedef) const;
+	virtual void decrementInput(CraftInput &input, IGameDef *gamedef) const;
+
+	virtual std::string dump() const;
+
+protected:
+	virtual void serializeBody(std::ostream &os) const;
+	virtual void deSerializeBody(std::istream &is, int version);
+
+private:
+	// This is a constant that is added to the wear of the result.
+	// May be positive or negative, allowed range [-1,1].
+	// 1 = new tool is completely broken
+	// 0 = simply add remaining uses of both input tools
+	// -1 = new tool is completely pristine
+	float additional_wear;
+};
+
+/*
+	A cooking (in furnace) definition
+	Supported crafting method: CRAFT_METHOD_COOKING.
+*/
+class CraftDefinitionCooking: public CraftDefinition
+{
+public:
+	CraftDefinitionCooking():
+		output(""), recipe(""), cooktime()
+	{}
+	CraftDefinitionCooking(
+			const std::string &output_,
+			const std::string &recipe_,
+			float cooktime_):
+		output(output_), recipe(recipe_), cooktime(cooktime_)
+	{}
+	virtual ~CraftDefinitionCooking(){}
+
+	virtual std::string getName() const;
+	virtual bool check(const CraftInput &input, IGameDef *gamedef) const;
+	virtual CraftOutput getOutput(const CraftInput &input, IGameDef *gamedef) const;
+	virtual void decrementInput(CraftInput &input, IGameDef *gamedef) const;
+
+	virtual std::string dump() const;
+
+protected:
+	virtual void serializeBody(std::ostream &os) const;
+	virtual void deSerializeBody(std::istream &is, int version);
+
+private:
+	// Output itemstring
+	std::string output;
+	// Recipe itemstring
+	std::string recipe;
+	// Time in seconds
+	float cooktime;
 };
 
+/*
+	A fuel (for furnace) definition
+	Supported crafting method: CRAFT_METHOD_FUEL.
+*/
+class CraftDefinitionFuel: public CraftDefinition
+{
+public:
+	CraftDefinitionFuel():
+		recipe(""), burntime()
+	{}
+	CraftDefinitionFuel(std::string recipe_, float burntime_):
+		recipe(recipe_), burntime(burntime_)
+	{}
+	virtual ~CraftDefinitionFuel(){}
+
+	virtual std::string getName() const;
+	virtual bool check(const CraftInput &input, IGameDef *gamedef) const;
+	virtual CraftOutput getOutput(const CraftInput &input, IGameDef *gamedef) const;
+	virtual void decrementInput(CraftInput &input, IGameDef *gamedef) const;
+
+	virtual std::string dump() const;
+
+protected:
+	virtual void serializeBody(std::ostream &os) const;
+	virtual void deSerializeBody(std::istream &is, int version);
+
+private:
+	// Recipe itemstring
+	std::string recipe;
+	// Time in seconds
+	float burntime;
+};
+
+/*
+	Crafting definition manager
+*/
 class ICraftDefManager
 {
 public:
 	ICraftDefManager(){}
 	virtual ~ICraftDefManager(){}
-	virtual InventoryItem* getCraftResult(const CraftPointerInput &input_cpi,
-			IGameDef *gamedef) const=0;
+
+	// The main crafting function
+	virtual bool getCraftResult(CraftInput &input, CraftOutput &output,
+			bool decrementInput, IGameDef *gamedef) const=0;
 	
-	virtual void serialize(std::ostream &os)=0;
+	// Print crafting recipes for debugging
+	virtual std::string dump() const=0;
+
+	virtual void serialize(std::ostream &os) const=0;
 };
 
 class IWritableCraftDefManager : public ICraftDefManager
@@ -95,13 +352,21 @@ class IWritableCraftDefManager : public ICraftDefManager
 public:
 	IWritableCraftDefManager(){}
 	virtual ~IWritableCraftDefManager(){}
-	virtual InventoryItem* getCraftResult(const CraftPointerInput &input_cpi,
-			IGameDef *gamedef) const=0;
-			
-	virtual void registerCraft(const CraftDefinition &def)=0;
+
+	// The main crafting function
+	virtual bool getCraftResult(CraftInput &input, CraftOutput &output,
+			bool decrementInput, IGameDef *gamedef) const=0;
+
+	// Print crafting recipes for debugging
+	virtual std::string dump() const=0;
+
+	// Add a crafting definition.
+	// After calling this, the pointer belongs to the manager.
+	virtual void registerCraft(CraftDefinition *def)=0;
+	// Delete all crafting definitions
 	virtual void clear()=0;
 
-	virtual void serialize(std::ostream &os)=0;
+	virtual void serialize(std::ostream &os) const=0;
 	virtual void deSerialize(std::istream &is)=0;
 };