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

diff --git a/src/inventorymanager.cpp b/src/inventorymanager.cpp
index 5412a5dca..1c511e9cb 100644
--- a/src/inventorymanager.cpp
+++ b/src/inventorymanager.cpp
@@ -1,6 +1,6 @@
 /*
-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 Lesser General Public License as published by
@@ -20,14 +20,17 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "inventorymanager.h"
 #include "log.h"
 #include "environment.h"
-#include "scriptapi.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()
+
 /*
 	InventoryLocation
 */
@@ -199,6 +202,14 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 		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);
+
 	/*
 		Collect information of endpoints
 	*/
@@ -217,9 +228,8 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 			to_inv.type == InventoryLocation::DETACHED &&
 			from_inv.name == to_inv.name)
 	{
-		lua_State *L = player->getEnv()->getLua();
-		src_can_take_count = scriptapi_detached_inventory_allow_move(
-				L, from_inv.name, from_list, from_i,
+		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;
 	}
@@ -228,18 +238,18 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 		// Destination is detached
 		if(to_inv.type == InventoryLocation::DETACHED)
 		{
-			lua_State *L = player->getEnv()->getLua();
 			ItemStack src_item = list_from->getItem(from_i);
 			src_item.count = try_take_count;
-			dst_can_put_count = scriptapi_detached_inventory_allow_put(
-					L, to_inv.name, to_list, to_i, src_item, player);
+			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)
 		{
-			lua_State *L = player->getEnv()->getLua();
-			src_can_take_count = scriptapi_detached_inventory_allow_take(
-					L, from_inv.name, from_list, from_i, try_take_count, player);
+			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);
 		}
 	}
 
@@ -251,9 +261,8 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 			to_inv.type == InventoryLocation::NODEMETA &&
 			from_inv.p == to_inv.p)
 	{
-		lua_State *L = player->getEnv()->getLua();
-		src_can_take_count = scriptapi_nodemeta_inventory_allow_move(
-				L, from_inv.p, from_list, from_i,
+		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;
 	}
@@ -262,33 +271,38 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 		// Destination is nodemeta
 		if(to_inv.type == InventoryLocation::NODEMETA)
 		{
-			lua_State *L = player->getEnv()->getLua();
 			ItemStack src_item = list_from->getItem(from_i);
 			src_item.count = try_take_count;
-			dst_can_put_count = scriptapi_nodemeta_inventory_allow_put(
-					L, to_inv.p, to_list, to_i, src_item, player);
+			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)
 		{
-			lua_State *L = player->getEnv()->getLua();
-			src_can_take_count = scriptapi_nodemeta_inventory_allow_take(
-					L, from_inv.p, from_list, from_i, try_take_count, player);
+			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);
 		}
 	}
+
+	int old_count = count;
 	
 	/* Modify count according to collected data */
-	int new_count = try_take_count;
-	if(new_count > src_can_take_count)
-		new_count = src_can_take_count;
-	if(new_count > dst_can_put_count)
-		new_count = dst_can_put_count;
+	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(new_count == 0)
+	if(count == 0)
 	{
-		infostream<<"IMoveAction::apply(): move was completely disallowed: "
-				<<" count="<<count
+		infostream<<"IMoveAction::apply(): move was completely disallowed:"
+				<<" count="<<old_count
 				<<" from inv=\""<<from_inv.dump()<<"\""
 				<<" list=\""<<from_list<<"\""
 				<<" i="<<from_i
@@ -299,7 +313,10 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 		return;
 	}
 
-	count = new_count;
+	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
@@ -309,7 +326,33 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 	*/
 	list_from->moveItem(from_i, list_to, to_i, count);
 
-	infostream<<"IMoveAction::apply(): moved "
+	// 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<<"\""
@@ -319,6 +362,41 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 			<<" 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
 	*/
@@ -330,9 +408,8 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 			to_inv.type == InventoryLocation::DETACHED &&
 			from_inv.name == to_inv.name)
 	{
-		lua_State *L = player->getEnv()->getLua();
-		scriptapi_detached_inventory_on_move(
-				L, from_inv.name, from_list, from_i,
+		PLAYER_TO_SA(player)->detached_inventory_OnMove(
+				from_inv.name, from_list, from_i,
 				to_list, to_i, count, player);
 	}
 	else
@@ -340,20 +417,14 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 		// Destination is detached
 		if(to_inv.type == InventoryLocation::DETACHED)
 		{
-			lua_State *L = player->getEnv()->getLua();
-			ItemStack src_item = list_from->getItem(from_i);
-			src_item.count = count;
-			scriptapi_detached_inventory_on_put(
-					L, to_inv.name, to_list, to_i, src_item, player);
+			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)
 		{
-			lua_State *L = player->getEnv()->getLua();
-			ItemStack src_item = list_from->getItem(from_i);
-			src_item.count = count;
-			scriptapi_detached_inventory_on_take(
-					L, from_inv.name, from_list, from_i, src_item.count, player);
+			PLAYER_TO_SA(player)->detached_inventory_OnTake(
+					from_inv.name, from_list, from_i, src_item, player);
 		}
 	}
 
@@ -364,32 +435,25 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 			to_inv.type == InventoryLocation::NODEMETA &&
 			from_inv.p == to_inv.p)
 	{
-		lua_State *L = player->getEnv()->getLua();
-		scriptapi_nodemeta_inventory_on_move(
-				L, from_inv.p, from_list, from_i,
+		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)
 		{
-			lua_State *L = player->getEnv()->getLua();
-			ItemStack src_item = list_from->getItem(from_i);
-			src_item.count = count;
-			scriptapi_nodemeta_inventory_on_put(
-					L, to_inv.p, to_list, to_i, src_item, player);
+			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)
 		{
-			lua_State *L = player->getEnv()->getLua();
-			ItemStack src_item = list_from->getItem(from_i);
-			src_item.count = count;
-			scriptapi_nodemeta_inventory_on_take(
-					L, from_inv.p, from_list, from_i, src_item.count, player);
+			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);
@@ -472,6 +536,11 @@ void IDropAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 		return;
 	}
 
+	/*
+		Do not handle rollback if inventory is player's
+	*/
+	bool ignore_src_rollback = (from_inv.type == InventoryLocation::PLAYER);
+
 	/*
 		Collect information of endpoints
 	*/
@@ -484,27 +553,32 @@ void IDropAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 	// Source is detached
 	if(from_inv.type == InventoryLocation::DETACHED)
 	{
-		lua_State *L = player->getEnv()->getLua();
-		src_can_take_count = scriptapi_detached_inventory_allow_take(
-				L, from_inv.name, from_list, from_i, take_count, player);
+		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);
 	}
 
 	// Source is nodemeta
 	if(from_inv.type == InventoryLocation::NODEMETA)
 	{
-		lua_State *L = player->getEnv()->getLua();
-		src_can_take_count = scriptapi_nodemeta_inventory_allow_take(
-				L, from_inv.p, from_list, from_i, take_count, player);
+		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 < take_count)
+	if(src_can_take_count != -1 && src_can_take_count < take_count)
 		take_count = src_can_take_count;
 	
 	int actually_dropped_count = 0;
 
+	ItemStack src_item = list_from->getItem(from_i);
+
 	// Drop the item
 	ItemStack item1 = list_from->getItem(from_i);
-	if(scriptapi_item_on_drop(player->getEnv()->getLua(), item1, player,
+	item1.count = take_count;
+	if(PLAYER_TO_SA(player)->item_OnDrop(item1, player,
 				player->getBasePosition() + v3f(0,1,0)))
 	{
 		actually_dropped_count = take_count - item1.count;
@@ -513,18 +587,15 @@ void IDropAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 			infostream<<"Actually dropped no items"<<std::endl;
 			return;
 		}
-
-		// Don't remove from inventory in creative mode
-		if(g_settings->getBool("creative_mode") == true
-				&& from_inv.type == InventoryLocation::PLAYER){
-		}
-		else{
+		
+		// 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);
 		}
 	}
@@ -534,6 +605,8 @@ void IDropAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 			<<" list=\""<<from_list<<"\""
 			<<" i="<<from_i
 			<<std::endl;
+	
+	src_item.count = actually_dropped_count;
 
 	/*
 		Report drop to endpoints
@@ -542,17 +615,37 @@ void IDropAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
 	// Source is detached
 	if(from_inv.type == InventoryLocation::DETACHED)
 	{
-		lua_State *L = player->getEnv()->getLua();
-		scriptapi_detached_inventory_on_take(
-				L, from_inv.name, from_list, from_i, actually_dropped_count, player);
+		PLAYER_TO_SA(player)->detached_inventory_OnTake(
+				from_inv.name, from_list, from_i, src_item, player);
 	}
 
 	// Source is nodemeta
 	if(from_inv.type == InventoryLocation::NODEMETA)
 	{
-		lua_State *L = player->getEnv()->getLua();
-		scriptapi_nodemeta_inventory_on_take(
-				L, from_inv.p, from_list, from_i, actually_dropped_count, player);
+		PLAYER_TO_SA(player)->nodemeta_inventory_OnTake(
+				from_inv.p, from_list, from_i, src_item, player);
+	}
+
+	/*
+		Record rollback information
+	*/
+	if(!ignore_src_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);
+		}
 	}
 }
 
@@ -631,13 +724,19 @@ void ICraftAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGam
 	}
 
 	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();
 
 	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);
 
@@ -654,6 +753,8 @@ void ICraftAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGam
 
 		// 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();
 	}
 
 	infostream<<"ICraftAction::apply(): crafted "
@@ -676,18 +777,16 @@ bool getCraftingResult(Inventory *inv, ItemStack& result,
 	
 	result.clear();
 
-	// TODO: Allow different sizes of crafting grids
-
 	// Get the InventoryList in which we will operate
 	InventoryList *clist = inv->getList("craft");
-	if(!clist || clist->getSize() != 9)
+	if(!clist)
 		return false;
 
 	// Mangle crafting grid to an another format
 	CraftInput ci;
 	ci.method = CRAFT_METHOD_NORMAL;
-	ci.width = 3;
-	for(u16 i=0; i<9; i++)
+	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
@@ -700,7 +799,7 @@ bool getCraftingResult(Inventory *inv, ItemStack& result,
 	if(found && decrementInput)
 	{
 		// CraftInput has been changed, apply changes in clist
-		for(u16 i=0; i<9; i++)
+		for(u16 i=0; i<clist->getSize(); i++)
 		{
 			clist->changeItem(i, ci.items[i]);
 		}