X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Finventorymanager.cpp;h=1c511e9cbe69f7659e70e8a7a1d5e172285af73b;hb=58e6d25e033c76dc91aaac18fdeda92ac23fe0e1;hp=195438d266013415799ac99205b296b9f252f21e;hpb=103173fc9b4fcb4c0fded2a93d5cbb8f0bea896e;p=oweals%2Fminetest.git

diff --git a/src/inventorymanager.cpp b/src/inventorymanager.cpp
index 195438d26..1c511e9cb 100644
--- a/src/inventorymanager.cpp
+++ b/src/inventorymanager.cpp
@@ -1,90 +1,113 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 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
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 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.
+GNU Lesser General Public License for more details.
 
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU Lesser 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.
 */
 
 #include "inventorymanager.h"
-#include "serverremoteplayer.h"
 #include "log.h"
-#include "mapblock.h" // getNodeBlockPos
+#include "environment.h"
+#include "scripting_game.h"
+#include "serverobject.h"
+#include "main.h"  // for g_settings
+#include "settings.h"
+#include "craftdef.h"
+#include "rollback_interface.h"
+
+#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
+
+#define PLAYER_TO_SA(p)   p->getEnv()->getScriptIface()
 
 /*
-	InventoryManager
+	InventoryLocation
 */
 
-// Wrapper for old code
-Inventory* InventoryManager::getInventory(InventoryContext *c, std::string id)
+std::string InventoryLocation::dump() const
 {
-	if(id == "current_player")
-	{
-		assert(c->current_player);
-		InventoryLocation loc;
-		loc.setPlayer(c->current_player->getName());
-		return getInventory(loc);
-	}
-	
-	Strfnd fn(id);
-	std::string id0 = fn.next(":");
-
-	if(id0 == "nodemeta")
-	{
-		v3s16 p;
-		p.X = stoi(fn.next(","));
-		p.Y = stoi(fn.next(","));
-		p.Z = stoi(fn.next(","));
+	std::ostringstream os(std::ios::binary);
+	serialize(os);
+	return os.str();
+}
 
-		InventoryLocation loc;
-		loc.setNodeMeta(p);
-		return getInventory(loc);
+void InventoryLocation::serialize(std::ostream &os) const
+{
+	switch(type){
+	case InventoryLocation::UNDEFINED:
+		os<<"undefined";
+		break;
+	case InventoryLocation::CURRENT_PLAYER:
+		os<<"current_player";
+		break;
+	case InventoryLocation::PLAYER:
+		os<<"player:"<<name;
+		break;
+	case InventoryLocation::NODEMETA:
+		os<<"nodemeta:"<<p.X<<","<<p.Y<<","<<p.Z;
+		break;
+	case InventoryLocation::DETACHED:
+		os<<"detached:"<<name;
+		break;
+	default:
+		assert(0);
 	}
-
-	errorstream<<__FUNCTION_NAME<<": unknown id "<<id<<std::endl;
-	return NULL;
 }
-// Wrapper for old code
-void InventoryManager::inventoryModified(InventoryContext *c, std::string id)
+
+void InventoryLocation::deSerialize(std::istream &is)
 {
-	if(id == "current_player")
+	std::string tname;
+	std::getline(is, tname, ':');
+	if(tname == "undefined")
 	{
-		assert(c->current_player);
-		InventoryLocation loc;
-		loc.setPlayer(c->current_player->getName());
-		setInventoryModified(loc);
-		return;
+		type = InventoryLocation::UNDEFINED;
 	}
-	
-	Strfnd fn(id);
-	std::string id0 = fn.next(":");
-
-	if(id0 == "nodemeta")
+	else if(tname == "current_player")
+	{
+		type = InventoryLocation::CURRENT_PLAYER;
+	}
+	else if(tname == "player")
+	{
+		type = InventoryLocation::PLAYER;
+		std::getline(is, name, '\n');
+	}
+	else if(tname == "nodemeta")
 	{
-		v3s16 p;
+		type = InventoryLocation::NODEMETA;
+		std::string pos;
+		std::getline(is, pos, '\n');
+		Strfnd fn(pos);
 		p.X = stoi(fn.next(","));
 		p.Y = stoi(fn.next(","));
 		p.Z = stoi(fn.next(","));
-		v3s16 blockpos = getNodeBlockPos(p);
-
-		InventoryLocation loc;
-		loc.setNodeMeta(p);
-		setInventoryModified(loc);
-		return;
 	}
+	else if(tname == "detached")
+	{
+		type = InventoryLocation::DETACHED;
+		std::getline(is, name, '\n');
+	}
+	else
+	{
+		infostream<<"Unknown InventoryLocation type=\""<<tname<<"\""<<std::endl;
+		throw SerializationError("Unknown InventoryLocation type");
+	}
+}
 
-	errorstream<<__FUNCTION_NAME<<": unknown id "<<id<<std::endl;
+void InventoryLocation::deSerialize(std::string s)
+{
+	std::istringstream is(s, std::ios::binary);
+	deSerialize(is);
 }
 
 /*
@@ -106,17 +129,17 @@ InventoryAction * InventoryAction::deSerialize(std::istream &is)
 	{
 		a = new IDropAction(is);
 	}
+	else if(type == "Craft")
+	{
+		a = new ICraftAction(is);
+	}
 
 	return a;
 }
 
-static std::string describeC(const struct InventoryContext *c)
-{
-	if(c->current_player == NULL)
-		return "current_player=NULL";
-	else
-		return std::string("current_player=") + c->current_player->getName();
-}
+/*
+	IMoveAction
+*/
 
 IMoveAction::IMoveAction(std::istream &is)
 {
@@ -125,14 +148,16 @@ IMoveAction::IMoveAction(std::istream &is)
 	std::getline(is, ts, ' ');
 	count = stoi(ts);
 
-	std::getline(is, from_inv, ' ');
+	std::getline(is, ts, ' ');
+	from_inv.deSerialize(ts);
 
 	std::getline(is, from_list, ' ');
 
 	std::getline(is, ts, ' ');
 	from_i = stoi(ts);
 
-	std::getline(is, to_inv, ' ');
+	std::getline(is, ts, ' ');
+	to_inv.deSerialize(ts);
 
 	std::getline(is, to_list, ' ');
 
@@ -140,22 +165,21 @@ IMoveAction::IMoveAction(std::istream &is)
 	to_i = stoi(ts);
 }
 
-void IMoveAction::apply(InventoryContext *c, InventoryManager *mgr,
-		ServerEnvironment *env)
+void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGameDef *gamedef)
 {
-	Inventory *inv_from = mgr->getInventory(c, from_inv);
-	Inventory *inv_to = mgr->getInventory(c, to_inv);
+	Inventory *inv_from = mgr->getInventory(from_inv);
+	Inventory *inv_to = mgr->getInventory(to_inv);
 	
 	if(!inv_from){
 		infostream<<"IMoveAction::apply(): FAIL: source inventory not found: "
-				<<"context=["<<describeC(c)<<"], from_inv=\""<<from_inv<<"\""
-				<<", to_inv=\""<<to_inv<<"\""<<std::endl;
+				<<"from_inv=\""<<from_inv.dump()<<"\""
+				<<", to_inv=\""<<to_inv.dump()<<"\""<<std::endl;
 		return;
 	}
 	if(!inv_to){
 		infostream<<"IMoveAction::apply(): FAIL: destination inventory not found: "
-				"context=["<<describeC(c)<<"], from_inv=\""<<from_inv<<"\""
-				<<", to_inv=\""<<to_inv<<"\""<<std::endl;
+				<<"from_inv=\""<<from_inv.dump()<<"\""
+				<<", to_inv=\""<<to_inv.dump()<<"\""<<std::endl;
 		return;
 	}
 
@@ -167,84 +191,306 @@ void IMoveAction::apply(InventoryContext *c, InventoryManager *mgr,
 	*/
 	if(!list_from){
 		infostream<<"IMoveAction::apply(): FAIL: source list not found: "
-				<<"context=["<<describeC(c)<<"], from_inv=\""<<from_inv<<"\""
+				<<"from_inv=\""<<from_inv.dump()<<"\""
 				<<", from_list=\""<<from_list<<"\""<<std::endl;
 		return;
 	}
 	if(!list_to){
 		infostream<<"IMoveAction::apply(): FAIL: destination list not found: "
-				<<"context=["<<describeC(c)<<"], to_inv=\""<<to_inv<<"\""
+				<<"to_inv=\""<<to_inv.dump()<<"\""
 				<<", to_list=\""<<to_list<<"\""<<std::endl;
 		return;
 	}
-	if(list_from->getItem(from_i) == NULL)
-	{
-		infostream<<"IMoveAction::apply(): FAIL: source item not found: "
-				<<"context=["<<describeC(c)<<"], from_inv=\""<<from_inv<<"\""
-				<<", from_list=\""<<from_list<<"\""
-				<<" from_i="<<from_i<<std::endl;
-		return;
-	}
+
+	/*
+		Do not handle rollback if both inventories are that of the same player
+	*/
+	bool ignore_rollback = (
+		from_inv.type == InventoryLocation::PLAYER &&
+		to_inv.type == InventoryLocation::PLAYER &&
+		from_inv.name == to_inv.name);
+
 	/*
-		If the source and the destination slots are the same
+		Collect information of endpoints
 	*/
-	if(inv_from == inv_to && list_from == list_to && from_i == to_i)
+
+	int try_take_count = count;
+	if(try_take_count == 0)
+		try_take_count = list_from->getItem(from_i).count;
+
+	int src_can_take_count = 0xffff;
+	int dst_can_put_count = 0xffff;
+	
+	/* Query detached inventories */
+
+	// Move occurs in the same detached inventory
+	if(from_inv.type == InventoryLocation::DETACHED &&
+			to_inv.type == InventoryLocation::DETACHED &&
+			from_inv.name == to_inv.name)
 	{
-		infostream<<"IMoveAction::apply(): FAIL: source and destination slots "
-				<<"are the same: inv=\""<<from_inv<<"\" list=\""<<from_list
-				<<"\" i="<<from_i<<std::endl;
-		return;
+		src_can_take_count = PLAYER_TO_SA(player)->detached_inventory_AllowMove(
+				from_inv.name, from_list, from_i,
+				to_list, to_i, try_take_count, player);
+		dst_can_put_count = src_can_take_count;
 	}
-	
-	// Take item from source list
-	InventoryItem *item1 = NULL;
-	if(count == 0)
-		item1 = list_from->changeItem(from_i, NULL);
 	else
-		item1 = list_from->takeItem(from_i, count);
+	{
+		// Destination is detached
+		if(to_inv.type == InventoryLocation::DETACHED)
+		{
+			ItemStack src_item = list_from->getItem(from_i);
+			src_item.count = try_take_count;
+			dst_can_put_count = PLAYER_TO_SA(player)->detached_inventory_AllowPut(
+					to_inv.name, to_list, to_i, src_item, player);
+		}
+		// Source is detached
+		if(from_inv.type == InventoryLocation::DETACHED)
+		{
+			ItemStack src_item = list_from->getItem(from_i);
+			src_item.count = try_take_count;
+			src_can_take_count = PLAYER_TO_SA(player)->detached_inventory_AllowTake(
+					from_inv.name, from_list, from_i, src_item, player);
+		}
+	}
 
-	// Try to add the item to destination list
-	InventoryItem *olditem = item1;
-	item1 = list_to->addItem(to_i, item1);
+	/* Query node metadata inventories */
 
-	// If something is returned, the item was not fully added
-	if(item1 != NULL)
+	// Both endpoints are nodemeta
+	// Move occurs in the same nodemeta inventory
+	if(from_inv.type == InventoryLocation::NODEMETA &&
+			to_inv.type == InventoryLocation::NODEMETA &&
+			from_inv.p == to_inv.p)
 	{
-		// If olditem is returned, nothing was added.
-		bool nothing_added = (item1 == olditem);
-		
-		// If something else is returned, part of the item was left unadded.
-		// Add the other part back to the source item
-		list_from->addItem(from_i, item1);
-
-		// If olditem is returned, nothing was added.
-		// Swap the items
-		if(nothing_added)
+		src_can_take_count = PLAYER_TO_SA(player)->nodemeta_inventory_AllowMove(
+				from_inv.p, from_list, from_i,
+				to_list, to_i, try_take_count, player);
+		dst_can_put_count = src_can_take_count;
+	}
+	else
+	{
+		// Destination is nodemeta
+		if(to_inv.type == InventoryLocation::NODEMETA)
 		{
-			// Take item from source list
-			item1 = list_from->changeItem(from_i, NULL);
-			// Adding was not possible, swap the items.
-			InventoryItem *item2 = list_to->changeItem(to_i, item1);
-			// Put item from destination list to the source list
-			list_from->changeItem(from_i, item2);
+			ItemStack src_item = list_from->getItem(from_i);
+			src_item.count = try_take_count;
+			dst_can_put_count = PLAYER_TO_SA(player)->nodemeta_inventory_AllowPut(
+					to_inv.p, to_list, to_i, src_item, player);
+		}
+		// Source is nodemeta
+		if(from_inv.type == InventoryLocation::NODEMETA)
+		{
+			ItemStack src_item = list_from->getItem(from_i);
+			src_item.count = try_take_count;
+			src_can_take_count = PLAYER_TO_SA(player)->nodemeta_inventory_AllowTake(
+					from_inv.p, from_list, from_i, src_item, player);
 		}
 	}
 
-	mgr->inventoryModified(c, from_inv);
-	if(from_inv != to_inv)
-		mgr->inventoryModified(c, to_inv);
+	int old_count = count;
 	
-	infostream<<"IMoveAction::apply(): moved at "
-			<<"["<<describeC(c)<<"]"
-			<<" from inv=\""<<from_inv<<"\""
+	/* Modify count according to collected data */
+	count = try_take_count;
+	if(src_can_take_count != -1 && count > src_can_take_count)
+		count = src_can_take_count;
+	if(dst_can_put_count != -1 && count > dst_can_put_count)
+		count = dst_can_put_count;
+	/* Limit according to source item count */
+	if(count > list_from->getItem(from_i).count)
+		count = list_from->getItem(from_i).count;
+	
+	/* If no items will be moved, don't go further */
+	if(count == 0)
+	{
+		infostream<<"IMoveAction::apply(): move was completely disallowed:"
+				<<" count="<<old_count
+				<<" from inv=\""<<from_inv.dump()<<"\""
+				<<" list=\""<<from_list<<"\""
+				<<" i="<<from_i
+				<<" to inv=\""<<to_inv.dump()<<"\""
+				<<" list=\""<<to_list<<"\""
+				<<" i="<<to_i
+				<<std::endl;
+		return;
+	}
+
+	ItemStack src_item = list_from->getItem(from_i);
+	src_item.count = count;
+	ItemStack from_stack_was = list_from->getItem(from_i);
+	ItemStack to_stack_was = list_to->getItem(to_i);
+
+	/*
+		Perform actual move
+
+		If something is wrong (source item is empty, destination is the
+		same as source), nothing happens
+	*/
+	list_from->moveItem(from_i, list_to, to_i, count);
+
+	// If source is infinite, reset it's stack
+	if(src_can_take_count == -1){
+		// If destination stack is of different type and there are leftover
+		// items, attempt to put the leftover items to a different place in the
+		// destination inventory.
+		// The client-side GUI will try to guess if this happens.
+		if(from_stack_was.name != to_stack_was.name){
+			for(u32 i=0; i<list_to->getSize(); i++){
+				if(list_to->getItem(i).empty()){
+					list_to->changeItem(i, to_stack_was);
+					break;
+				}
+			}
+		}
+		list_from->deleteItem(from_i);
+		list_from->addItem(from_i, from_stack_was);
+	}
+	// If destination is infinite, reset it's stack and take count from source
+	if(dst_can_put_count == -1){
+		list_to->deleteItem(to_i);
+		list_to->addItem(to_i, to_stack_was);
+		list_from->deleteItem(from_i);
+		list_from->addItem(from_i, from_stack_was);
+		list_from->takeItem(from_i, count);
+	}
+
+	infostream<<"IMoveAction::apply(): moved"
+			<<" count="<<count
+			<<" from inv=\""<<from_inv.dump()<<"\""
 			<<" list=\""<<from_list<<"\""
 			<<" i="<<from_i
-			<<" to inv=\""<<to_inv<<"\""
+			<<" to inv=\""<<to_inv.dump()<<"\""
 			<<" list=\""<<to_list<<"\""
 			<<" i="<<to_i
 			<<std::endl;
+
+	/*
+		Record rollback information
+	*/
+	if(!ignore_rollback && gamedef->rollback())
+	{
+		IRollbackReportSink *rollback = gamedef->rollback();
+
+		// If source is not infinite, record item take
+		if(src_can_take_count != -1){
+			RollbackAction action;
+			std::string loc;
+			{
+				std::ostringstream os(std::ios::binary);
+				from_inv.serialize(os);
+				loc = os.str();
+			}
+			action.setModifyInventoryStack(loc, from_list, from_i, false,
+					src_item.getItemString());
+			rollback->reportAction(action);
+		}
+		// If destination is not infinite, record item put
+		if(dst_can_put_count != -1){
+			RollbackAction action;
+			std::string loc;
+			{
+				std::ostringstream os(std::ios::binary);
+				to_inv.serialize(os);
+				loc = os.str();
+			}
+			action.setModifyInventoryStack(loc, to_list, to_i, true,
+					src_item.getItemString());
+			rollback->reportAction(action);
+		}
+	}
+
+	/*
+		Report move to endpoints
+	*/
+	
+	/* Detached inventories */
+
+	// Both endpoints are same detached
+	if(from_inv.type == InventoryLocation::DETACHED &&
+			to_inv.type == InventoryLocation::DETACHED &&
+			from_inv.name == to_inv.name)
+	{
+		PLAYER_TO_SA(player)->detached_inventory_OnMove(
+				from_inv.name, from_list, from_i,
+				to_list, to_i, count, player);
+	}
+	else
+	{
+		// Destination is detached
+		if(to_inv.type == InventoryLocation::DETACHED)
+		{
+			PLAYER_TO_SA(player)->detached_inventory_OnPut(
+					to_inv.name, to_list, to_i, src_item, player);
+		}
+		// Source is detached
+		if(from_inv.type == InventoryLocation::DETACHED)
+		{
+			PLAYER_TO_SA(player)->detached_inventory_OnTake(
+					from_inv.name, from_list, from_i, src_item, player);
+		}
+	}
+
+	/* Node metadata inventories */
+
+	// Both endpoints are same nodemeta
+	if(from_inv.type == InventoryLocation::NODEMETA &&
+			to_inv.type == InventoryLocation::NODEMETA &&
+			from_inv.p == to_inv.p)
+	{
+		PLAYER_TO_SA(player)->nodemeta_inventory_OnMove(
+				from_inv.p, from_list, from_i,
+				to_list, to_i, count, player);
+	}
+	else{
+		// Destination is nodemeta
+		if(to_inv.type == InventoryLocation::NODEMETA)
+		{
+			PLAYER_TO_SA(player)->nodemeta_inventory_OnPut(
+					to_inv.p, to_list, to_i, src_item, player);
+		}
+		// Source is nodemeta
+		else if(from_inv.type == InventoryLocation::NODEMETA)
+		{
+			PLAYER_TO_SA(player)->nodemeta_inventory_OnTake(
+					from_inv.p, from_list, from_i, src_item, player);
+		}
+	}
+	
+	mgr->setInventoryModified(from_inv);
+	if(inv_from != inv_to)
+		mgr->setInventoryModified(to_inv);
+}
+
+void IMoveAction::clientApply(InventoryManager *mgr, IGameDef *gamedef)
+{
+	// Optional InventoryAction operation that is run on the client
+	// to make lag less apparent.
+
+	Inventory *inv_from = mgr->getInventory(from_inv);
+	Inventory *inv_to = mgr->getInventory(to_inv);
+	if(!inv_from || !inv_to)
+		return;
+
+	InventoryLocation current_player;
+	current_player.setCurrentPlayer();
+	Inventory *inv_player = mgr->getInventory(current_player);
+	if(inv_from != inv_player || inv_to != inv_player)
+		return;
+
+	InventoryList *list_from = inv_from->getList(from_list);
+	InventoryList *list_to = inv_to->getList(to_list);
+	if(!list_from || !list_to)
+		return;
+
+	list_from->moveItem(from_i, list_to, to_i, count);
+
+	mgr->setInventoryModified(from_inv);
+	if(inv_from != inv_to)
+		mgr->setInventoryModified(to_inv);
 }
 
+/*
+	IDropAction
+*/
+
 IDropAction::IDropAction(std::istream &is)
 {
 	std::string ts;
@@ -252,7 +498,8 @@ IDropAction::IDropAction(std::istream &is)
 	std::getline(is, ts, ' ');
 	count = stoi(ts);
 
-	std::getline(is, from_inv, ' ');
+	std::getline(is, ts, ' ');
+	from_inv.deSerialize(ts);
 
 	std::getline(is, from_list, ' ');
 
@@ -260,27 +507,13 @@ IDropAction::IDropAction(std::istream &is)
 	from_i = stoi(ts);
 }
 
-void IDropAction::apply(InventoryContext *c, InventoryManager *mgr,
-		ServerEnvironment *env)
+void IDropAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGameDef *gamedef)
 {
-	if(c->current_player == NULL){
-		infostream<<"IDropAction::apply(): FAIL: current_player is NULL"<<std::endl;
-		return;
-	}
-
-	// Do NOT cast directly to ServerActiveObject*, it breaks
-	// because of multiple inheritance.
-	ServerActiveObject *dropper =
-		static_cast<ServerActiveObject*>(
-		static_cast<ServerRemotePlayer*>(
-			c->current_player
-		));
-
-	Inventory *inv_from = mgr->getInventory(c, from_inv);
+	Inventory *inv_from = mgr->getInventory(from_inv);
 	
 	if(!inv_from){
 		infostream<<"IDropAction::apply(): FAIL: source inventory not found: "
-				<<"context=["<<describeC(c)<<"], from_inv=\""<<from_inv<<"\""<<std::endl;
+				<<"from_inv=\""<<from_inv.dump()<<"\""<<std::endl;
 		return;
 	}
 
@@ -291,254 +524,287 @@ void IDropAction::apply(InventoryContext *c, InventoryManager *mgr,
 	*/
 	if(!list_from){
 		infostream<<"IDropAction::apply(): FAIL: source list not found: "
-				<<"context=["<<describeC(c)<<"], from_inv=\""<<from_inv<<"\""
-				<<", from_list=\""<<from_list<<"\""<<std::endl;
+				<<"from_inv=\""<<from_inv.dump()<<"\""<<std::endl;
 		return;
 	}
-	InventoryItem *item = list_from->getItem(from_i);
-	if(item == NULL)
+	if(list_from->getItem(from_i).empty())
 	{
 		infostream<<"IDropAction::apply(): FAIL: source item not found: "
-				<<"context=["<<describeC(c)<<"], from_inv=\""<<from_inv<<"\""
+				<<"from_inv=\""<<from_inv.dump()<<"\""
 				<<", from_list=\""<<from_list<<"\""
 				<<" from_i="<<from_i<<std::endl;
 		return;
 	}
 
-	v3f pos = dropper->getBasePosition();
-	pos.Y += 0.5*BS;
-
-	s16 count2 = count;
-	if(count2 == 0)
-		count2 = -1;
-
 	/*
-		Drop the item
+		Do not handle rollback if inventory is player's
 	*/
-	bool remove = item->dropOrPlace(env, dropper, pos, false, count2);
-	if(remove)
-		list_from->deleteItem(from_i);
+	bool ignore_src_rollback = (from_inv.type == InventoryLocation::PLAYER);
 
-	mgr->inventoryModified(c, from_inv);
+	/*
+		Collect information of endpoints
+	*/
 
-	infostream<<"IDropAction::apply(): dropped "
-			<<"["<<describeC(c)<<"]"
-			<<" from inv=\""<<from_inv<<"\""
-			<<" list=\""<<from_list<<"\""
-			<<" i="<<from_i
-			<<std::endl;
-}
+	int take_count = list_from->getItem(from_i).count;
+	if(count != 0 && count < take_count)
+		take_count = count;
+	int src_can_take_count = take_count;
 
-/*
-	Craft checking system
-*/
+	// Source is detached
+	if(from_inv.type == InventoryLocation::DETACHED)
+	{
+		ItemStack src_item = list_from->getItem(from_i);
+		src_item.count = take_count;
+		src_can_take_count = PLAYER_TO_SA(player)->detached_inventory_AllowTake(
+				from_inv.name, from_list, from_i, src_item, player);
+	}
 
-bool ItemSpec::checkItem(const InventoryItem *item) const
-{
-	if(type == ITEM_NONE)
+	// Source is nodemeta
+	if(from_inv.type == InventoryLocation::NODEMETA)
 	{
-		// Has to be no item
-		if(item != NULL)
-			return false;
-		return true;
+		ItemStack src_item = list_from->getItem(from_i);
+		src_item.count = take_count;
+		src_can_take_count = PLAYER_TO_SA(player)->nodemeta_inventory_AllowTake(
+				from_inv.p, from_list, from_i, src_item, player);
 	}
+
+	if(src_can_take_count != -1 && src_can_take_count < take_count)
+		take_count = src_can_take_count;
 	
-	// There should be an item
-	if(item == NULL)
-		return false;
+	int actually_dropped_count = 0;
 
-	std::string itemname = item->getName();
+	ItemStack src_item = list_from->getItem(from_i);
 
-	if(type == ITEM_MATERIAL)
+	// Drop the item
+	ItemStack item1 = list_from->getItem(from_i);
+	item1.count = take_count;
+	if(PLAYER_TO_SA(player)->item_OnDrop(item1, player,
+				player->getBasePosition() + v3f(0,1,0)))
 	{
-		if(itemname != "MaterialItem")
-			return false;
-		MaterialItem *mitem = (MaterialItem*)item;
-		if(num != 65535){
-			if(mitem->getMaterial() != num)
-				return false;
-		} else {
-			if(mitem->getNodeName() != name)
-				return false;
+		actually_dropped_count = take_count - item1.count;
+
+		if(actually_dropped_count == 0){
+			infostream<<"Actually dropped no items"<<std::endl;
+			return;
+		}
+		
+		// If source isn't infinite
+		if(src_can_take_count != -1){
+			// Take item from source list
+			ItemStack item2 = list_from->takeItem(from_i, actually_dropped_count);
+
+			if(item2.count != actually_dropped_count)
+				errorstream<<"Could not take dropped count of items"<<std::endl;
+
+			mgr->setInventoryModified(from_inv);
 		}
 	}
-	else if(type == ITEM_CRAFT)
+
+	infostream<<"IDropAction::apply(): dropped "
+			<<" from inv=\""<<from_inv.dump()<<"\""
+			<<" list=\""<<from_list<<"\""
+			<<" i="<<from_i
+			<<std::endl;
+	
+	src_item.count = actually_dropped_count;
+
+	/*
+		Report drop to endpoints
+	*/
+	
+	// Source is detached
+	if(from_inv.type == InventoryLocation::DETACHED)
 	{
-		if(itemname != "CraftItem")
-			return false;
-		CraftItem *mitem = (CraftItem*)item;
-		if(mitem->getSubName() != name)
-			return false;
+		PLAYER_TO_SA(player)->detached_inventory_OnTake(
+				from_inv.name, from_list, from_i, src_item, player);
 	}
-	else if(type == ITEM_TOOL)
+
+	// Source is nodemeta
+	if(from_inv.type == InventoryLocation::NODEMETA)
 	{
-		// Not supported yet
-		assert(0);
+		PLAYER_TO_SA(player)->nodemeta_inventory_OnTake(
+				from_inv.p, from_list, from_i, src_item, player);
 	}
-	else if(type == ITEM_MBO)
+
+	/*
+		Record rollback information
+	*/
+	if(!ignore_src_rollback && gamedef->rollback())
 	{
-		// Not supported yet
-		assert(0);
+		IRollbackReportSink *rollback = gamedef->rollback();
+
+		// If source is not infinite, record item take
+		if(src_can_take_count != -1){
+			RollbackAction action;
+			std::string loc;
+			{
+				std::ostringstream os(std::ios::binary);
+				from_inv.serialize(os);
+				loc = os.str();
+			}
+			action.setModifyInventoryStack(loc, from_list, from_i,
+					false, src_item.getItemString());
+			rollback->reportAction(action);
+		}
 	}
+}
+
+void IDropAction::clientApply(InventoryManager *mgr, IGameDef *gamedef)
+{
+	// Optional InventoryAction operation that is run on the client
+	// to make lag less apparent.
+
+	Inventory *inv_from = mgr->getInventory(from_inv);
+	if(!inv_from)
+		return;
+
+	InventoryLocation current_player;
+	current_player.setCurrentPlayer();
+	Inventory *inv_player = mgr->getInventory(current_player);
+	if(inv_from != inv_player)
+		return;
+
+	InventoryList *list_from = inv_from->getList(from_list);
+	if(!list_from)
+		return;
+
+	if(count == 0)
+		list_from->changeItem(from_i, ItemStack());
 	else
-	{
-		// Not supported yet
-		assert(0);
-	}
-	return true;
+		list_from->takeItem(from_i, count);
+
+	mgr->setInventoryModified(from_inv);
 }
 
-bool checkItemCombination(InventoryItem const * const *items, const ItemSpec *specs)
+/*
+	ICraftAction
+*/
+
+ICraftAction::ICraftAction(std::istream &is)
 {
-	u16 items_min_x = 100;
-	u16 items_max_x = 100;
-	u16 items_min_y = 100;
-	u16 items_max_y = 100;
-	for(u16 y=0; y<3; y++)
-	for(u16 x=0; x<3; x++)
-	{
-		if(items[y*3 + x] == NULL)
-			continue;
-		if(items_min_x == 100 || x < items_min_x)
-			items_min_x = x;
-		if(items_min_y == 100 || y < items_min_y)
-			items_min_y = y;
-		if(items_max_x == 100 || x > items_max_x)
-			items_max_x = x;
-		if(items_max_y == 100 || y > items_max_y)
-			items_max_y = y;
-	}
-	// No items at all, just return false
-	if(items_min_x == 100)
-		return false;
+	std::string ts;
+
+	std::getline(is, ts, ' ');
+	count = stoi(ts);
+
+	std::getline(is, ts, ' ');
+	craft_inv.deSerialize(ts);
+}
+
+void ICraftAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGameDef *gamedef)
+{
+	Inventory *inv_craft = mgr->getInventory(craft_inv);
 	
-	u16 items_w = items_max_x - items_min_x + 1;
-	u16 items_h = items_max_y - items_min_y + 1;
-
-	u16 specs_min_x = 100;
-	u16 specs_max_x = 100;
-	u16 specs_min_y = 100;
-	u16 specs_max_y = 100;
-	for(u16 y=0; y<3; y++)
-	for(u16 x=0; x<3; x++)
-	{
-		if(specs[y*3 + x].type == ITEM_NONE)
-			continue;
-		if(specs_min_x == 100 || x < specs_min_x)
-			specs_min_x = x;
-		if(specs_min_y == 100 || y < specs_min_y)
-			specs_min_y = y;
-		if(specs_max_x == 100 || x > specs_max_x)
-			specs_max_x = x;
-		if(specs_max_y == 100 || y > specs_max_y)
-			specs_max_y = y;
-	}
-	// No specs at all, just return false
-	if(specs_min_x == 100)
-		return false;
+	if(!inv_craft){
+		infostream<<"ICraftAction::apply(): FAIL: inventory not found: "
+				<<"craft_inv=\""<<craft_inv.dump()<<"\""<<std::endl;
+		return;
+	}
 
-	u16 specs_w = specs_max_x - specs_min_x + 1;
-	u16 specs_h = specs_max_y - specs_min_y + 1;
+	InventoryList *list_craft = inv_craft->getList("craft");
+	InventoryList *list_craftresult = inv_craft->getList("craftresult");
 
-	// Different sizes
-	if(items_w != specs_w || items_h != specs_h)
-		return false;
+	/*
+		If a list doesn't exist or the source item doesn't exist
+	*/
+	if(!list_craft){
+		infostream<<"ICraftAction::apply(): FAIL: craft list not found: "
+				<<"craft_inv=\""<<craft_inv.dump()<<"\""<<std::endl;
+		return;
+	}
+	if(!list_craftresult){
+		infostream<<"ICraftAction::apply(): FAIL: craftresult list not found: "
+				<<"craft_inv=\""<<craft_inv.dump()<<"\""<<std::endl;
+		return;
+	}
+	if(list_craftresult->getSize() < 1){
+		infostream<<"ICraftAction::apply(): FAIL: craftresult list too short: "
+				<<"craft_inv=\""<<craft_inv.dump()<<"\""<<std::endl;
+		return;
+	}
 
-	for(u16 y=0; y<specs_h; y++)
-	for(u16 x=0; x<specs_w; x++)
-	{
-		u16 items_x = items_min_x + x;
-		u16 items_y = items_min_y + y;
-		u16 specs_x = specs_min_x + x;
-		u16 specs_y = specs_min_y + y;
-		const InventoryItem *item = items[items_y * 3 + items_x];
-		const ItemSpec &spec = specs[specs_y * 3 + specs_x];
+	ItemStack crafted;
+	ItemStack craftresultitem;
+	int count_remaining = count;
+	bool found = getCraftingResult(inv_craft, crafted, false, gamedef);
+	PLAYER_TO_SA(player)->item_CraftPredict(crafted, player, list_craft, craft_inv);
+	found = !crafted.empty();
 
-		if(spec.checkItem(item) == false)
-			return false;
+	while(found && list_craftresult->itemFits(0, crafted))
+	{
+		InventoryList saved_craft_list = *list_craft;
+		
+		// Decrement input and add crafting output
+		getCraftingResult(inv_craft, crafted, true, gamedef);
+		PLAYER_TO_SA(player)->item_OnCraft(crafted, player, &saved_craft_list, craft_inv);
+		list_craftresult->addItem(0, crafted);
+		mgr->setInventoryModified(craft_inv);
+
+		actionstream<<player->getDescription()
+				<<" crafts "
+				<<crafted.getItemString()
+				<<std::endl;
+
+		// Decrement counter
+		if(count_remaining == 1)
+			break;
+		else if(count_remaining > 1)
+			count_remaining--;
+
+		// Get next crafting result
+		found = getCraftingResult(inv_craft, crafted, false, gamedef);
+		PLAYER_TO_SA(player)->item_CraftPredict(crafted, player, list_craft, craft_inv);
+		found = !crafted.empty();
 	}
 
-	return true;
+	infostream<<"ICraftAction::apply(): crafted "
+			<<" craft_inv=\""<<craft_inv.dump()<<"\""
+			<<std::endl;
 }
 
-bool checkItemCombination(const InventoryItem * const * items,
-		const InventoryItem * const * specs)
+void ICraftAction::clientApply(InventoryManager *mgr, IGameDef *gamedef)
 {
-	u16 items_min_x = 100;
-	u16 items_max_x = 100;
-	u16 items_min_y = 100;
-	u16 items_max_y = 100;
-	for(u16 y=0; y<3; y++)
-	for(u16 x=0; x<3; x++)
-	{
-		if(items[y*3 + x] == NULL)
-			continue;
-		if(items_min_x == 100 || x < items_min_x)
-			items_min_x = x;
-		if(items_min_y == 100 || y < items_min_y)
-			items_min_y = y;
-		if(items_max_x == 100 || x > items_max_x)
-			items_max_x = x;
-		if(items_max_y == 100 || y > items_max_y)
-			items_max_y = y;
-	}
-	// No items at all, just return false
-	if(items_min_x == 100)
-		return false;
-	
-	u16 items_w = items_max_x - items_min_x + 1;
-	u16 items_h = items_max_y - items_min_y + 1;
-
-	u16 specs_min_x = 100;
-	u16 specs_max_x = 100;
-	u16 specs_min_y = 100;
-	u16 specs_max_y = 100;
-	for(u16 y=0; y<3; y++)
-	for(u16 x=0; x<3; x++)
-	{
-		if(specs[y*3 + x] == NULL)
-			continue;
-		if(specs_min_x == 100 || x < specs_min_x)
-			specs_min_x = x;
-		if(specs_min_y == 100 || y < specs_min_y)
-			specs_min_y = y;
-		if(specs_max_x == 100 || x > specs_max_x)
-			specs_max_x = x;
-		if(specs_max_y == 100 || y > specs_max_y)
-			specs_max_y = y;
-	}
-	// No specs at all, just return false
-	if(specs_min_x == 100)
-		return false;
+	// Optional InventoryAction operation that is run on the client
+	// to make lag less apparent.
+}
 
-	u16 specs_w = specs_max_x - specs_min_x + 1;
-	u16 specs_h = specs_max_y - specs_min_y + 1;
 
-	// Different sizes
-	if(items_w != specs_w || items_h != specs_h)
+// Crafting helper
+bool getCraftingResult(Inventory *inv, ItemStack& result,
+		bool decrementInput, IGameDef *gamedef)
+{
+	DSTACK(__FUNCTION_NAME);
+	
+	result.clear();
+
+	// Get the InventoryList in which we will operate
+	InventoryList *clist = inv->getList("craft");
+	if(!clist)
 		return false;
 
-	for(u16 y=0; y<specs_h; y++)
-	for(u16 x=0; x<specs_w; x++)
+	// Mangle crafting grid to an another format
+	CraftInput ci;
+	ci.method = CRAFT_METHOD_NORMAL;
+	ci.width = clist->getWidth() ? clist->getWidth() : 3;
+	for(u16 i=0; i<clist->getSize(); i++)
+		ci.items.push_back(clist->getItem(i));
+
+	// Find out what is crafted and add it to result item slot
+	CraftOutput co;
+	bool found = gamedef->getCraftDefManager()->getCraftResult(
+			ci, co, decrementInput, gamedef);
+	if(found)
+		result.deSerialize(co.item, gamedef->getItemDefManager());
+
+	if(found && decrementInput)
 	{
-		u16 items_x = items_min_x + x;
-		u16 items_y = items_min_y + y;
-		u16 specs_x = specs_min_x + x;
-		u16 specs_y = specs_min_y + y;
-		const InventoryItem *item = items[items_y * 3 + items_x];
-		const InventoryItem *spec = specs[specs_y * 3 + specs_x];
-		
-		if(item == NULL && spec == NULL)
-			continue;
-		if(item == NULL && spec != NULL)
-			return false;
-		if(item != NULL && spec == NULL)
-			return false;
-		if(!spec->isSubsetOf(item))
-			return false;
+		// CraftInput has been changed, apply changes in clist
+		for(u16 i=0; i<clist->getSize(); i++)
+		{
+			clist->changeItem(i, ci.items[i]);
+		}
 	}
 
-	return true;
+	return found;
 }
 
-