mirror of
https://gitea.your-land.de/Sokomine/yl_speak_up.git
synced 2025-06-19 05:38:02 +02:00
607 lines
24 KiB
Lua
607 lines
24 KiB
Lua
|
|
-- Which diffrent types of effects are available?
|
|
-- -> The following fields are part of an effect/result:
|
|
-- r_id the ID/key of the effect/result
|
|
-- r_type selected from values_what; the staffs allow to use other
|
|
-- types like "function" or "give_item" etc. - but that is not
|
|
-- supported here (cannot be edited or created; only be shown)
|
|
-- r_value used to store the subtype of r_type
|
|
--
|
|
-- a state/variable:
|
|
-- r_variable name of a variable the player has *write* access to;
|
|
-- dropdown list with allowed options
|
|
-- r_operator selected from values_operator
|
|
-- r_var_cmp_value can be set freely by the player (the variable will be
|
|
-- set to this value)
|
|
--
|
|
-- a block in the world:
|
|
-- r_pos a position in the world; determined by asking the player
|
|
-- to punch the block
|
|
-- r_node (follows from r_pos)
|
|
-- r_param2 (follows from r_pos)
|
|
--
|
|
-- a craft receipe:
|
|
-- r_value the expected craft result
|
|
-- r_craft_grid array containing the stacks in the 9 craft grid fields in string form
|
|
--
|
|
-- on_failure:
|
|
-- r_value alternate target dialog if the previous *effect* failed
|
|
--
|
|
-- chat_all:
|
|
-- r_value chat message sent to all players
|
|
--
|
|
-- Unlike in preconditions, trade (the trade action already happened) and
|
|
-- inventory actions are not supported as effects.
|
|
--
|
|
|
|
-- some helper lists for creating the formspecs and evaulating
|
|
-- the player's answers:
|
|
|
|
-- general direction of what could make up an effect
|
|
local check_what = {
|
|
"- please select -",
|
|
"an internal state (i.e. of a quest)", -- 2
|
|
"a block somewhere", -- 3
|
|
"NPC crafts soemthing", -- 4
|
|
"go to other dialog if the action (i.e. trade) failed", -- 5
|
|
"send a chat message to all players", -- 6
|
|
}
|
|
|
|
-- how to store these as r_type in the precondition:
|
|
local values_what = {"", "state", "block", "craft", "on_failure", "chat_all"}
|
|
|
|
-- unlike in the preconditions, the "I cannot punch it" option is
|
|
-- not offered here - because the player (and later the NPC) needs
|
|
-- to be able to build at this position
|
|
local check_block = {
|
|
"- please select -", -- 1
|
|
"If there is air: Place a block so that it looks like now.", -- 2
|
|
"If there is a block: Dig it.", -- 3
|
|
"Punch the block.", -- 4
|
|
"Right-click the block.", -- 5
|
|
}
|
|
|
|
-- how to store these as p_value (the actual node data gets stored as p_node, p_param2 and p_pos):
|
|
local values_block = {"", "place", "dig", "punch", "right-click"}
|
|
|
|
-- comparison operators for variables
|
|
local check_operator = {
|
|
"- please select -", -- 1
|
|
"set to value:", -- 2
|
|
"is no longer needed (unset)", -- 3
|
|
}
|
|
|
|
-- how to store these as r_value (the actual variable is stored in r_variable, and the value in r_new_value):
|
|
local values_operator = {"", "set_to", "unset"}
|
|
|
|
|
|
-- get the list of variables the player has *write* access to
|
|
yl_speak_up.get_sorted_player_var_list_write_access = function(pname)
|
|
local var_list = {}
|
|
-- some values - like hour of day or HP of the player - can be read in
|
|
-- a precondition but not be modified
|
|
-- get the list of variables the player can *write*
|
|
local tmp = yl_speak_up.get_quest_variables_with_write_access(pname)
|
|
-- sort that list (the dropdown formspec element returns just an index)
|
|
table.sort(tmp)
|
|
for i, v in ipairs(tmp) do
|
|
table.insert(var_list, v)
|
|
end
|
|
return var_list
|
|
end
|
|
|
|
|
|
-- returns a human-readable text as description of the effects
|
|
-- (as shown in the edit options dialog and in the edit effect formspec)
|
|
yl_speak_up.show_effect = function(r)
|
|
if(not(r.r_type) or r.r_type == "") then
|
|
return "(nothing): Nothing to do. No effect."
|
|
elseif(r.r_type == "give_item") then
|
|
return "give_item: Add \""..tostring(r.r_value).."\" to the player's inventory."
|
|
elseif(r.r_type == "take_item") then
|
|
return "take_item: Take \""..tostring(r.r_value).."\" from the player's inventory."
|
|
elseif(r.r_type == "move") then
|
|
return "move: Move the player to "..tostring(r.r_value).."."
|
|
elseif(r.r_type == "function") then
|
|
return "function: execute \""..tostring(r.r_value).."\"."
|
|
elseif(r.r_type == "trade") then
|
|
return "trade: obsolete (now defined as an action)"
|
|
elseif(r.r_type == "dialog") then
|
|
return "Switch to dialog \""..tostring(r.r_value).."\"."
|
|
elseif(r.r_type == "state") then
|
|
if(not(r.r_operator)) then
|
|
return "Error: Operator not defined."
|
|
elseif(r.r_operator == "set_to") then
|
|
return "set VARIABLE[ "..tostring(r.r_variable).." ] to value \""..
|
|
tostring(r.r_var_cmp_value).."\""
|
|
elseif(r.r_operator == "unset") then
|
|
return "discard VARIABLE[ "..tostring(r.r_variable).." ] (unset)"
|
|
else
|
|
return "ERROR: Wrong operator \""..tostring(r.r_operator).."\" for "..
|
|
"VARIABLE[ "..tostring(r.r_variable).." ]"
|
|
end
|
|
elseif(r.r_type == "block") then
|
|
if(not(r.r_pos) or type(r.r_pos) ~= "table"
|
|
or not(r.r_pos.x) or not(r.r_pos.y) or not(r.r_pos.z)) then
|
|
return "ERROR: r.r_pos is "..minetest.serialize(r.r_pos)
|
|
elseif(r.r_value == "place") then
|
|
return "Place \""..tostring(r.r_node).."\" with param2: "..tostring(r.r_param2)..
|
|
" at "..minetest.pos_to_string(r.r_pos).."."
|
|
elseif(r.r_value == "dig") then
|
|
return "Dig the block at "..minetest.pos_to_string(r.r_pos).."."
|
|
elseif(r.r_value == "punch") then
|
|
return "Punch the block at "..minetest.pos_to_string(r.r_pos).."."
|
|
elseif(r.r_value == "right-click") then
|
|
return "Right-click the block at "..minetest.pos_to_string(r.r_pos).."."
|
|
else
|
|
return "ERROR: Don't know what to do with the block at "..
|
|
minetest.pos_to_string(r.r_pos)..": \""..tostring(r.r_value).."\"?"
|
|
end
|
|
elseif(r.r_type == "craft") then
|
|
-- this is only shown in the edit options menu and when editing an effect;
|
|
-- we can afford a bit of calculation here (it's not a precondtion...)
|
|
if(not(r.r_value) or not(r.r_craft_grid)) then
|
|
return "ERROR: Crafting not configured correctly."
|
|
end
|
|
local craft_str = "Craft \""..tostring(r.r_value).."\" from "..
|
|
table.concat(r.r_craft_grid, ", ").."."
|
|
-- check here if the craft receipe is broken
|
|
local input = {}
|
|
input.items = {}
|
|
for i, v in ipairs(r.r_craft_grid) do
|
|
input.items[ i ] = ItemStack(v or "")
|
|
end
|
|
input.method = "normal" -- normal crafting; no cooking or fuel or the like
|
|
input.width = 3
|
|
local output, decremented_input = minetest.get_craft_result(input)
|
|
if(output.item:is_empty()) then
|
|
return "Error: Recipe changed! No output for "..craft_str
|
|
end
|
|
-- the craft receipe may have changed in the meantime and yield a diffrent result
|
|
local expected_stack = ItemStack(r.r_value)
|
|
if(output.item:get_name() ~= expected_stack:get_name()
|
|
or output.item:get_count() ~= expected_stack:get_count()) then
|
|
return "Error: Amount of output changed! "..craft_str
|
|
end
|
|
return craft_str
|
|
elseif(r.r_type == "on_failure") then
|
|
return "If the *previous* effect failed, go to dialog \""..tostring(r.r_value).. "\"."
|
|
elseif(r.r_type == "chat_all") then
|
|
return "Send chat message: \""..tostring(r.r_value).."\""
|
|
end
|
|
-- fallback
|
|
return tostring(r.r_value)
|
|
end
|
|
|
|
|
|
-- called by yl_speak_up.input_talk(..)
|
|
--
|
|
-- This function is called *after* the player has clicked on an option
|
|
-- and *after* any actions (i.e. trade) have been completed either
|
|
-- successfully (=action_was_succesful is true) or not.
|
|
-- Unlike the preconditions, the effects are executed in ordered form,
|
|
-- ordered by their r_id.
|
|
-- Returns the new target dialog that is to be displayed next. This will
|
|
-- usually be the one with the r_type "dialog" - unless r_type "on_failure"
|
|
-- was encountered after an unsuccessful action *or* right after an
|
|
-- effect that returned false.
|
|
-- Note: In edit mode, effects will *not* be executed.
|
|
yl_speak_up.execute_all_relevant_effects = function(player, effects, o_id, action_was_successful)
|
|
local target_dialog = ""
|
|
if(not(effects)) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, "No effects given.")
|
|
-- no effects? Then...return to the start dialog
|
|
return ""
|
|
end
|
|
local pname = player:get_player_name()
|
|
local n_id = yl_speak_up.speak_to[pname].n_id
|
|
local edit_mode = (yl_speak_up.edit_mode[pname] == n_id)
|
|
if(not(edit_mode)) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, "Executing effects.")
|
|
else
|
|
yl_speak_up.debug_msg(player, n_id, o_id, "Not executing effects because in edit mode.")
|
|
end
|
|
local last_result = action_was_successful
|
|
-- Important: the list of effects is *sorted* here. The order remains constant!
|
|
local sorted_key_list = yl_speak_up.sort_keys(effects)
|
|
local res = true
|
|
for i, k in ipairs(sorted_key_list) do
|
|
local r = effects[ k ]
|
|
yl_speak_up.debug_msg(player, n_id, o_id, "..executing "..
|
|
tostring(r.r_id)..": "..yl_speak_up.show_effect(r))
|
|
-- do not execute effects in edit mode
|
|
if(not(edit_mode)) then
|
|
res = yl_speak_up.execute_effect(player, n_id, o_id, r)
|
|
if(not(res)) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id)..
|
|
" -> Effect failed to execute.")
|
|
end
|
|
end
|
|
-- "dialog" gives us the normal target_dialog
|
|
if(r.r_type and r.r_type == "dialog") then
|
|
target_dialog = r.r_value
|
|
-- "on_failure" gives an alternate target dialog if the action
|
|
-- or last effect failed
|
|
elseif(r.r_type and r.r_type == "on_failure" and r.r_value and not(last_result)) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, "Aborted executing effects at "..
|
|
tostring(r.r_id)..". New target dialog: "..tostring(r.r_value)..".")
|
|
-- we also stop execution here
|
|
return r.r_value
|
|
end
|
|
last_result = res
|
|
end
|
|
-- all preconditions are true
|
|
yl_speak_up.debug_msg(player, n_id, o_id, "Finished executing effects.")
|
|
return target_dialog
|
|
end
|
|
|
|
|
|
-- executes an effect/result r for the player and npc n_id;
|
|
-- returns true on success (relevant for on_failure)
|
|
-- Note: In edit mode, this function does not get called.
|
|
yl_speak_up.execute_effect = function(player, n_id, o_id, r)
|
|
if(not(r.r_type) or r.r_type == "") then
|
|
-- nothing to do
|
|
return true
|
|
elseif(r.r_type == "auto" or r.r_type == "trade") then
|
|
-- these effects don't do anything
|
|
return true
|
|
elseif(r.r_type == "dialog"
|
|
or r.r_type == "on_failure") then
|
|
-- this needs to be handled in the calling function
|
|
return true
|
|
elseif(r.r_type == "function") then
|
|
-- this can only be set and edited with the staff
|
|
return yl_speak_up.eval_and_execute_function(player, r, "r_")
|
|
-- this can only be set and edited with the staff
|
|
elseif(r.r_type == "give_item") then
|
|
if(not(r.r_value)) then
|
|
return false
|
|
end
|
|
local item = ItemStack(r.r_value)
|
|
if(not(minetest.registered_items[item:get_name()])) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"give_item: "..tostring(item:get_name()).." unknown.")
|
|
return false
|
|
end
|
|
local r = player:get_inventory():add_item("main", item)
|
|
if(not(r)) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"give_item: "..tostring(item:get_name()).." failed.")
|
|
return false
|
|
end
|
|
return true
|
|
-- this can only be set and edited with the staff
|
|
elseif(r.r_type == "take_item") then
|
|
if(not(r.r_value)) then
|
|
return false
|
|
end
|
|
local item = ItemStack(r.r_value)
|
|
if(not(minetest.registered_items[item:get_name()])) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"take_item: "..tostring(item:get_name()).." unknown.")
|
|
return false
|
|
end
|
|
local r = player:get_inventory():remove_item("main", item)
|
|
if(not(r)) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"take_item: "..tostring(item:get_name()).." failed.")
|
|
return false
|
|
end
|
|
return true
|
|
-- this can only be set and edited with the staff
|
|
elseif(r.r_type == "move") then
|
|
-- copeid/moved here from AliasAlreadyTakens code in functions.lua
|
|
local target_pos = nil
|
|
local target_pos_valid = false
|
|
|
|
--pos like (100,20,400)
|
|
if minetest.string_to_pos(r.r_value) then
|
|
target_pos = minetest.string_to_pos(r.r_value)
|
|
target_pos_valid = true
|
|
end
|
|
|
|
--pos like 100,20,400
|
|
local maybe = string.split(r.r_value, ",")
|
|
if not target_pos_valid and maybe and tonumber(maybe[1])
|
|
and tonumber(maybe[2]) and tonumber(maybe[3]) and maybe[4] == nil and
|
|
tonumber(maybe[1]) <= 32000 and tonumber(maybe[1]) >= -32000 and
|
|
tonumber(maybe[2]) <= 32000 and tonumber(maybe[2]) >= -32000 and
|
|
tonumber(maybe[3]) <= 32000 and tonumber(maybe[3]) >= -32000 then
|
|
target_pos = {x=maybe[1],y=maybe[2],z=maybe[3]}
|
|
target_pos_valid = true
|
|
end
|
|
|
|
--pos like {x=100,y=20,z=400}
|
|
if not target_pos_valid and string.sub(r.r_value,1,1) == "{"
|
|
and string.sub(r.r_value,-1,-1) == "}" then
|
|
local might_be_pos = minetest.deserialize("return " .. r.r_value)
|
|
if tonumber(might_be_pos.x)
|
|
and tonumber(might_be_pos.x) <= 32000
|
|
and tonumber(might_be_pos.x) >= -32000
|
|
and tonumber(might_be_pos.y)
|
|
and tonumber(might_be_pos.y) <= 32000
|
|
and tonumber(might_be_pos.y) >= -32000
|
|
and tonumber(might_be_pos.z)
|
|
and tonumber(might_be_pos.z) <= 32000
|
|
and tonumber(might_be_pos.z) >= -32000 then
|
|
target_pos = might_be_pos
|
|
target_pos_valid = true
|
|
end
|
|
end
|
|
|
|
if target_pos_valid == true then
|
|
player:set_pos(target_pos)
|
|
if vector.distance(player:get_pos(),target_pos) >= 2 then
|
|
yl_speak_up.log_change(pname, n_id, tostring(r.r_id)..": "..
|
|
"Something went wrong! Player wasn't moved properly.")
|
|
end
|
|
end
|
|
|
|
-- Debug
|
|
if target_pos_valid == false then
|
|
local obj = yl_speak_up.speak_to[pname].obj
|
|
local n_id = yl_speak_up.speak_to[pname].n_id
|
|
local npc = get_number_from_id(n_id)
|
|
if obj:get_luaentity() and tonumber(npc) then
|
|
yl_speak_up.log_change(pname, n_id, tostring(r.r_id)..": "..
|
|
"NPC at "..minetest.pos_to_string(obj:get_pos(),0)..
|
|
" could not move player "..pname.." because the content of "..
|
|
tostring(r.r_id).." is wrong:"..dump(r.r_value))
|
|
else
|
|
yl_speak_up.log_change(pname, n_id, tostring(r.r_id)..": "..
|
|
"NPC with unknown ID or without proper object "..
|
|
" could not move player "..pname.." because the content of "..
|
|
tostring(r.r_id).." is wrong:"..dump(r.r_value))
|
|
end
|
|
return false
|
|
end
|
|
return true
|
|
|
|
-- "an internal state (i.e. of a quest)", -- 2
|
|
elseif(r.r_type == "state") then
|
|
if(not(r.r_variable) or r.r_variable == "") then
|
|
return false
|
|
end
|
|
local pname = player:get_player_name()
|
|
local owner = yl_speak_up.npc_owner[ n_id ]
|
|
-- set the value of the variable
|
|
local new_value = nil
|
|
if( r.r_operator and r.r_operator == "set_to") then
|
|
new_value = r.r_var_cmp_value
|
|
elseif(r.r_operator and r.r_operator == "unset") then
|
|
new_value = nil
|
|
else
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"state: Unsupported type: "..tostring(r.r_value)..".")
|
|
return false
|
|
end
|
|
local ret = yl_speak_up.set_quest_variable_value(owner, pname, r.r_variable, new_value)
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"state: Success: "..tostring(ret).." for setting "..tostring(r.r_variable).." to "..
|
|
tostring(new_value)..".")
|
|
return ret
|
|
-- "a block somewhere" -- 3
|
|
elseif(r.r_type == "block") then
|
|
-- is the position given correctly?
|
|
if(not(r.r_pos) or type(r.r_pos) ~= "table"
|
|
or not(r.r_pos.x) or not(r.r_pos.y) or not(r.r_pos.z)) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"block: Missing or wrong position given: "..
|
|
minetest.serialize(r.r_pos)..".")
|
|
return false
|
|
end
|
|
-- check protection (relevant for some actions): the *owner*
|
|
-- of the NPC needs to be able to build there
|
|
local is_protected = minetest.is_protected(r.r_pos, yl_speak_up.npc_owner[ n_id ] or "?")
|
|
-- human readable position; mostly for debug messages
|
|
local pos_str = tostring(minetest.pos_to_string(r.r_pos))
|
|
-- the area has to be loaded
|
|
local node = minetest.get_node_or_nil(r.r_pos)
|
|
if(not(node)) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"block: Not loaded (nil) at pos "..pos_str..".")
|
|
return false
|
|
end
|
|
-- "If there is air: Place a block so that it looks like now.", -- 2
|
|
if(r.r_value and r.r_value == "place") then
|
|
if(is_protected) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"block: place - "..pos_str.." is protected. Can't place.")
|
|
return false
|
|
end
|
|
if(not(node) or not(node.name) or node.name ~= "air") then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"block: place - there is already a block at pos "..pos_str..
|
|
". Can't place.")
|
|
return false
|
|
end
|
|
-- does the NPC have this block in his inventory? else he can't place it
|
|
local npc_inv = minetest.get_inventory({type="detached",
|
|
name="yl_speak_up_npc_"..tostring(n_id)})
|
|
if(not(npc_inv:contains_item("npc_main", tostring(r.r_node)))) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"block: place - NPC does not have "..tostring(r.r_node)..
|
|
" in his inventory for placing at "..pos_str..".")
|
|
return false
|
|
end
|
|
-- TODO: switch to minetest.place_node in the future once the bug with placing
|
|
-- on an air node is fixed
|
|
-- actually place the node
|
|
minetest.set_node(r.r_pos, {name=r.r_node, param2=r.r_param2})
|
|
-- consume the item
|
|
npc_inv:remove_item("npc_main", tostring(r.r_node))
|
|
return true
|
|
-- "If there is a block: Dig it.", -- 3
|
|
elseif(r.r_value and r.r_value == "dig") then
|
|
if(is_protected) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"block: place - "..pos_str.." is protected. Can't place.")
|
|
return false
|
|
end
|
|
if(not(node) or not(node.name) or node.name == "air"
|
|
or not(minetest.registered_items[ node.name ])) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"block: dig - there is no block at pos "..pos_str..".")
|
|
return false
|
|
end
|
|
-- TODO: use dig_node once that can put the items in the inventory
|
|
-- local dig_res = minetest.dig_node(r.r_pos)
|
|
if(minetest.registered_items[ node.name ].can_dig
|
|
and not(minetest.registered_items[ node.name ].can_dig(r.r_pos))) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"block: dig - Can't dig block at pos "..pos_str..".")
|
|
return false
|
|
end
|
|
-- actually remove the node
|
|
minetest.remove_node(r.r_pos)
|
|
-- get node drops when digging without a tool
|
|
local drop_list = minetest.get_node_drops(node, nil)
|
|
local npc_inv = minetest.get_inventory({type="detached",
|
|
name="yl_speak_up_npc_"..tostring(n_id)})
|
|
-- put the drops into the inventory of the NPC
|
|
for i, d in ipairs(drop_list) do
|
|
local rest = npc_inv:add_item("npc_main", ItemStack(d))
|
|
if(rest and not(rest:is_empty()) and rest:get_count()>0) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id)..
|
|
" block: dig (info) - NPC had no room for item drop "..
|
|
rest:to_string().." from digging at "..pos_str..".")
|
|
end
|
|
end
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"block: dig - success: "..tostring(dig_res).." at pos "..pos_str..".")
|
|
return true
|
|
-- "Punch the block.", -- 4
|
|
elseif(r.r_value and r.r_value == "punch") then
|
|
-- even air can be punched - even if that is pretty pointless
|
|
minetest.punch_node(r.r_pos)
|
|
return true
|
|
-- "Right-click the block.", -- 5
|
|
elseif(r.r_value and r.r_value == "right-click") then
|
|
-- TODO: not sure if right-clicking a block (as an npc) is possible without bugs
|
|
end
|
|
return false
|
|
-- ""NPC crafts soemthing", -- 4
|
|
elseif(r.r_type == "craft") then
|
|
if(not(r.r_craft_grid) or not(r.r_value)) then
|
|
return false
|
|
end
|
|
local input = {}
|
|
input.items = {}
|
|
-- multiple slots in the craft grid may contain the same item
|
|
local sum_up = {}
|
|
for i, v in ipairs(r.r_craft_grid) do
|
|
if(v and v ~= "") then
|
|
local stack = ItemStack(v)
|
|
-- store this for later crafting
|
|
input.items[ i ] = stack
|
|
local name = stack:get_name()
|
|
if(sum_up[ name ]) then
|
|
sum_up[ name ] = sum_up[ name ] + stack:get_count()
|
|
else
|
|
sum_up[ name ] = stack:get_count()
|
|
end
|
|
else
|
|
-- empty itemstack in this slot
|
|
input.items[ i ] = ItemStack("")
|
|
end
|
|
end
|
|
-- does the NPC have all these items in his inventory?
|
|
local npc_inv = minetest.get_inventory({type="detached",
|
|
name="yl_speak_up_npc_"..tostring(n_id)})
|
|
for k, v in pairs(sum_up) do
|
|
if(not(npc_inv:contains_item("npc_main", k.." "..v))) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"Crafting failed: NPC does not have "..tostring(k.." "..v))
|
|
return false
|
|
end
|
|
end
|
|
-- do these input items form a valid craft recipe?
|
|
input.method = "normal" -- normal crafting; no cooking or fuel or the like
|
|
input.width = 3
|
|
local output, decremented_input = minetest.get_craft_result(input)
|
|
if(output.item:is_empty()) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"Crafting failed: No output for that recipe.")
|
|
return false
|
|
end
|
|
-- the craft receipe may have changed in the meantime and yield a diffrent result
|
|
local expected_stack = ItemStack(r.r_value)
|
|
if(output.item:get_name() ~= expected_stack:get_name()
|
|
or output.item:get_count() ~= expected_stack:get_count()) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"Crafting failed: Diffrent output: "..tostring(output.item:to_string()))
|
|
return false
|
|
end
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"Great: Crafting is possible!")
|
|
-- actually consume the items required, return the ones in decremented_input
|
|
for i, v in ipairs(r.r_craft_grid) do
|
|
if(v and v ~= "") then
|
|
npc_inv:remove_item("npc_main", ItemStack(v))
|
|
end
|
|
end
|
|
-- add the craft result
|
|
if(not(npc_inv:room_for_item("npc_main", output.item))) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"No room for craft result "..output.item:to_string())
|
|
end
|
|
npc_inv:add_item("npc_main", output.item)
|
|
-- add the decremented_inputs
|
|
for k,v in pairs(decremented_input.items) do
|
|
if(k and not(v:is_empty())) then
|
|
if(not(npc_inv:room_for_item("npc_main", v))) then
|
|
yl_speak_up.debug_msg(player, n_id, o_id, tostring(r.r_id).." "..
|
|
"No room for craft decr. input "..v:to_string())
|
|
end
|
|
-- actually give the decremented input to the NPC
|
|
npc_inv:add_item("npc_main", v)
|
|
end
|
|
end
|
|
return true
|
|
-- "send a chat message to all players", -- 6
|
|
elseif(r.r_type == "chat_all") then
|
|
local pname = player:get_player_name()
|
|
local dialog = yl_speak_up.speak_to[pname].dialog
|
|
local text = r.r_value
|
|
-- replace $NPC_NAME$, $OWNER_NAME$, $PLAYER_NAME$ etc.
|
|
text = yl_speak_up.replace_vars_in_text(text, dialog, pname)
|
|
minetest.chat_send_all(text)
|
|
-- sending a chat message always counts as successful
|
|
return true
|
|
end
|
|
-- fallback: unkown type
|
|
return false
|
|
end
|
|
|
|
|
|
-- these are only wrapper functions for those in fs_edit_general.lua
|
|
|
|
yl_speak_up.input_fs_edit_effects = function(player, formname, fields)
|
|
return yl_speak_up.input_fs_edit_option_related(player, formname, fields,
|
|
"r_", "o_results", yl_speak_up.max_result_effects,
|
|
"(Ef)fect", "tmp_result",
|
|
"Please punch the block you want to manipulate in your effect!",
|
|
values_what, values_operator, values_block, {}, {},
|
|
check_what, check_operator, check_block, {}, {},
|
|
-- player variables with write access
|
|
yl_speak_up.get_sorted_player_var_list_write_access,
|
|
"edit_effects"
|
|
)
|
|
end
|
|
|
|
yl_speak_up.get_fs_edit_effects = function(player, table_click_result)
|
|
return yl_speak_up.get_fs_edit_option_related(player, table_click_result,
|
|
"r_", "o_results", yl_speak_up.max_result_effects,
|
|
"(Ef)fect", "tmp_result",
|
|
"What do you want to change with this effect?",
|
|
check_what, check_operator, check_block, {}, {},
|
|
-- player variables with write access
|
|
yl_speak_up.get_sorted_player_var_list_write_access,
|
|
yl_speak_up.show_effect,
|
|
"table_of_elements",
|
|
"Change the value of the following variable:", "What to do:", "New value:",
|
|
"The NPC shall do something to the block at the following position:"
|
|
)
|
|
end
|