nalc
/
advanced_npc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
advanced_npc/trade/trade.lua

768 lines
32 KiB
Lua
Raw Permalink Blame History

-- Trading code for Advanced NPC by Zorman2000
npc.trade = {}
npc.trade.CASUAL = "casual"
npc.trade.TRADER = "trader"
npc.trade.NONE = "none"
npc.trade.OFFER_BUY = "buy"
npc.trade.OFFER_SELL = "sell"
-- This variable establishes how much items a dedicated
-- trader will buy until retiring the offer
npc.trade.DEDICATED_MAX_BUY_AMOUNT = 5
-- This table holds all responses for trades
npc.trade.results = {
single_trade_offer = {},
trade_offers = {},
custom_trade_offer = {}
}
-- This is the text to be shown each time the NPC has more
-- than one custom trade options to choose from
npc.trade.CUSTOM_TRADES_PROMPT_TEXT = "Hi there, how can I help you today?"
-- Casual trader NPC dialogues definition
-- Casual buyer
npc.dialogue.register_dialogue({
text = "I'm looking to buy some items, are you interested?",
--casual_trade_type = npc.trade.OFFER_BUY,
tags = {"default_casual_trade_dialogue", "buy_offer"},
--dialogue_type = npc.dialogue.dialogue_type.casual_trade,
responses = {
[1] = {
text = "Sell",
action_type = "function",
response_id = 1,
action = function(self, player)
npc.trade.show_trade_offer_formspec(self, player, npc.trade.OFFER_BUY)
end
}
}
})
-- npc.trade.CASUAL_TRADE_BUY_DIALOGUE = {
-- text = "I'm looking to buy some items, are you interested?",
-- casual_trade_type = npc.trade.OFFER_BUY,
-- dialogue_type = npc.dialogue.dialogue_type.casual_trade,
-- responses = {
-- [1] = {
-- text = "Sell",
-- action_type = "function",
-- response_id = 1,
-- action = function(self, player)
-- npc.trade.show_trade_offer_formspec(self, player, npc.trade.OFFER_BUY)
-- end
-- }
-- }
-- }
-- Casual seller
npc.dialogue.register_dialogue({
text = "I have some items to sell, are you interested?",
--dialogue_type = npc.dialogue.dialogue_type.casual_trade,
tags = {"default_casual_trade_dialogue", "sell_offer"},
--casual_trade_type = npc.trade.OFFER_SELL,
responses = {
[1] = {
text = "Buy",
action_type = "function",
response_id = 1,
action = function(self, player)
npc.trade.show_trade_offer_formspec(self, player, npc.trade.OFFER_SELL)
end
}
}
})
-- npc.trade.CASUAL_TRADE_SELL_DIALOGUE = {
-- text = "I have some items to sell, are you interested?",
-- dialogue_type = npc.dialogue.dialogue_type.casual_trade,
-- casual_trade_type = npc.trade.OFFER_SELL,
-- responses = {
-- [1] = {
-- text = "Buy",
-- action_type = "function",
-- response_id = 1,
-- action = function(self, player)
-- npc.trade.show_trade_offer_formspec(self, player, npc.trade.OFFER_SELL)
-- end
-- }
-- }
-- }
-- Dedicated trade dialogue prompt
npc.dialogue.register_dialogue({
text = "Hello there, would you like to trade?",
tags = {npc.dialogue.tags.DEFAULT_DEDICATED_TRADE},
dialogue_type = npc.dialogue.dialogue_type.dedicated_trade,
responses = {
[1] = {
text = "Buy",
action_type = "function",
response_id = 1,
action = function(self, player)
npc.trade.show_dedicated_trade_formspec(self, player, npc.trade.OFFER_SELL)
end
},
[2] = {
text = "Sell",
action_type = "function",
response_id = 2,
action = function(self, player)
npc.trade.show_dedicated_trade_formspec(self, player, npc.trade.OFFER_BUY)
end
},
[3] = {
text = "Other",
action_type = "function",
response_id = 3,
action = function(self, player)
local dialogue = npc.dialogue.create_custom_trade_options(self, player)
npc.dialogue.process_dialogue(self, dialogue, player:get_player_name())
end
}
}
})
-- npc.trade.DEDICATED_TRADER_PROMPT = {
-- text = "Hello there, would you like to trade?",
-- dialogue_type = npc.dialogue.dialogue_type.dedicated_trade,
-- responses = {
-- [1] = {
-- text = "Buy",
-- action_type = "function",
-- response_id = 1,
-- action = function(self, player)
-- npc.trade.show_dedicated_trade_formspec(self, player, npc.trade.OFFER_SELL)
-- end
-- },
-- [2] = {
-- text = "Sell",
-- action_type = "function",
-- response_id = 2,
-- action = function(self, player)
-- npc.trade.show_dedicated_trade_formspec(self, player, npc.trade.OFFER_BUY)
-- end
-- },
-- [3] = {
-- text = "Other",
-- action_type = "function",
-- response_id = 3,
-- action = function(self, player)
-- local dialogue = npc.dialogue.create_custom_trade_options(self, player)
-- npc.dialogue.process_dialogue(self, dialogue, player:get_player_name())
-- end
-- }
-- }
-- }
function npc.trade.show_trade_offer_formspec(self, player, offer_type)
-- Strings for formspec, to include international support later
local prompt_string = " offers to buy from you"
local for_string = "for"
local buy_sell_string = "Sell"
-- Get offer. As this is casual trading, NPCs will only have
-- one trade offer
local trade_offer = self.trader_data.buy_offers[1]
if offer_type == npc.trade.OFFER_SELL then
trade_offer = self.trader_data.sell_offers[1]
prompt_string = " wants to sell to you"
buy_sell_string = "Buy"
end
local formspec = "size[8,4]"..
default.gui_bg..
default.gui_bg_img..
default.gui_slots..
"label[2,0.1;"..self.npc_name..prompt_string.."]"..
"item_image_button[2,1.3;1.2,1.2;"..trade_offer.item..";item;]"..
"label[3.75,1.75;"..for_string.."]"..
"item_image_button[4.8,1.3;1.2,1.2;"..trade_offer.price[1]..";price;]"..
"button_exit[1,3.3;2.9,0.5;yes_option;"..buy_sell_string.."]"..
"button_exit[4.1,3.3;2.9,0.5;no_option;"..npc.dialogue.NEGATIVE_ANSWER_LABEL.."]"
-- Create entry into results table
npc.trade.results.single_trade_offer[player:get_player_name()] = {
trade_offer = trade_offer,
npc = self
}
-- Show formspec to player
minetest.show_formspec(player:get_player_name(), "advanced_npc:trade_offer", formspec)
end
function npc.trade.show_dedicated_trade_formspec(self, player, offers_type)
-- Choose the correct offers
local offers = self.trader_data.buy_offers
local menu_offer_type = "sell"
if offers_type == npc.trade.OFFER_SELL then
offers = self.trader_data.sell_offers
menu_offer_type = "buy"
end
-- Create a grid with the items for trade offer
local max_columns = 4
local current_x = 0.2
local current_y = 0.5
local current_col = 1
local current_row = 1
local formspec = "size[8.9,8.2]"..
default.gui_bg..
default.gui_bg_img..
default.gui_slots..
"label[0.2,0.05;Click on the price button to "..menu_offer_type.." item]"
for i = 1, #offers do
local price_item_name = minetest.registered_items[npc.get_item_name(offers[i].price[1])].description
local count_label = ""
if npc.get_item_count(offers[i].item) > 1 then
count_label = "label["..(current_x + 1.35)..","..(current_y + 1)..";"..npc.get_item_count(offers[i].item).."]"
end
formspec = formspec..
"box["..current_x..","..current_y..";2,2.3;#212121]"..
"item_image["..(current_x + 0.45)..","..(current_y + 0.15)..";1.3,1.3;"..npc.get_item_name(offers[i].item).."]"..
count_label..
"item_image_button["..(current_x + 1.15)..","..(current_y + 1.4)..";1,1;"..offers[i].price[1]..";price"..i..";]"..
"label["..(current_x + 0.15)..","..(current_y + 1.7)..";Price]"
current_x = current_x + 2.1
current_col = current_col + 1
if current_col > 4 then
current_col = 1
current_x = 0.2
current_y = current_y + 2.4
end
end
formspec = formspec .. "button_exit[2.5,7.9;3.9,0.5;exit;Nevermind]"
-- Create entry into results table
npc.trade.results.trade_offers[player:get_player_name()] = {
offers_type = offers_type,
offers = offers,
npc = self
}
minetest.show_formspec(player:get_player_name(), "advanced_npc:dedicated_trading_offers", formspec)
end
-- For the moment, the trade offer for custom trade is always of sell type
function npc.trade.show_custom_trade_offer(self, player, offer)
local for_string = "for"
-- Create payments grid. Try to center it. When there are 4
-- payment options, a grid is to be displayed.
local price_count = #offer.price
local start_x = 2
local margin_x = 0
local start_y = 1.45
if price_count == 2 then
start_x = 1.5
margin_x = 0.3
elseif price_count == 3 then
start_x = 1.15
margin_x = 0.85
elseif price_count == 4 then
start_x = 1.5
start_y = 0.8
margin_x = 0.3
end
-- Create payment grid
local price_grid = ""
for i = 1, #offer.price do
price_grid = price_grid.."item_image_button["..start_x..","..start_y..";1,1;"..offer.price[i]..";price"..i..";]"
if #offer.price == 4 and i == 2 then
start_x = 1.5
start_y = start_y + 1
else
start_x = start_x + 1
end
end
local formspec = "size[8,4]"..
default.gui_bg..
default.gui_bg_img..
default.gui_slots..
"label[2,0.1;"..self.npc_name..": "..offer.dialogue_prompt.."]"..
price_grid..
"label["..(margin_x + 3.75)..",1.75;"..for_string.."]"..
"item_image_button["..(margin_x + 4.8)..",1.3;1.2,1.2;"..offer.item..";item;]"..
"button_exit[1,3.3;2.9,0.5;yes_option;"..offer.button_prompt.."]"..
"button_exit[4.1,3.3;2.9,0.5;no_option;"..npc.dialogue.NEGATIVE_ANSWER_LABEL.."]"
-- Create entry into results table
npc.trade.results.custom_trade_offer[player:get_player_name()] = {
trade_offer = offer,
npc = self
}
-- Show formspec to player
minetest.show_formspec(player:get_player_name(), "advanced_npc:custom_trade_offer", formspec)
end
function npc.trade.get_random_trade_status()
local chance = math.random(1,10)
if chance < 3 then
-- Non-trader
return npc.trade.NONE
elseif 3 <= chance and chance <= 7 then
-- Casual trader
return npc.trade.CASUAL
elseif chance > 7 then
-- Trader by profession
return npc.trade.TRADER
end
end
-- This function generates and stores on the NPC data trade
-- offers depending on the trader status.
function npc.trade.generate_trade_offers_by_status(self)
-- Get trader status
local status = self.trader_data.trader_status
-- Check what is the trader status
if status == npc.trade.NONE then
-- For none, clear all offers
self.trader_data.buy_offers = {}
self.trader_data.sell_offers = {}
elseif status == npc.trade.CASUAL then
-- For casual, generate one buy and one sell offer
self.trader_data.buy_offers = {
[1] = npc.trade.get_casual_trade_offer(self, npc.trade.OFFER_BUY)
}
self.trader_data.sell_offers = {
[1] = npc.trade.get_casual_trade_offer(self, npc.trade.OFFER_SELL)
}
elseif status == npc.trade.TRADER then
-- Clear current offers
self.trader_data.buy_offers = {}
self.trader_data.sell_offers = {}
-- Get trade offers for a dedicated trader
local offers = npc.trade.get_dedicated_trade_offers(self)
-- Store buy offers
for i = 1, #offers.buy do
table.insert(self.trader_data.buy_offers, offers.buy[i])
end
-- Store sell offers
for i = 1, #offers.sell do
table.insert(self.trader_data.sell_offers, offers.sell[i])
end
end
end
-- Convenience method that retrieves all the currency
-- items that a NPC has on his/her inventory
function npc.trade.get_currencies_in_inventory(self)
local result = {}
local tier3 = npc.inventory_contains(self, npc.trade.prices.currency.tier3.string)
local tier2 = npc.inventory_contains(self, npc.trade.prices.currency.tier2.string)
local tier1 = npc.inventory_contains(self, npc.trade.prices.currency.tier1.string)
if tier3 ~= nil then
table.insert(result, {name = npc.get_item_name(tier3.item_string),
count = npc.get_item_count(tier3.item_string)} )
end
if tier2 ~= nil then
table.insert(result, {name = npc.get_item_name(tier2.item_string),
count = npc.get_item_count(tier2.item_string)} )
end
if tier1 ~= nil then
table.insert(result, {name = npc.get_item_name(tier1.item_string),
count = npc.get_item_count(tier1.item_string)} )
end
--minetest.log("Found currency in inventory: "..dump(result))
return result
end
-- This function will return an offer object, based
-- on the items the NPC has.
function npc.trade.get_casual_trade_offer(self, offer_type)
local result = {}
-- Check offer type
if offer_type == npc.trade.OFFER_BUY then
-- Create buy offer based on what the NPC can actually buy
local currencies = npc.trade.get_currencies_in_inventory(self)
-- Choose a random currency
local chosen_tier = currencies[math.random(#currencies)]
-- Get items for this currency
local buyable_items =
npc.trade.prices.get_items_for_currency_count(chosen_tier.name, chosen_tier.count, 0.5)
-- Select a random item from the buyable items
local item_set = {}
for item,price_info in pairs(buyable_items) do
table.insert(item_set, item)
end
local item = item_set[math.random(#item_set)]
-- Choose buying quantity. Since this is a buy offer, NPC will buy items
-- at half the price. Therefore, NPC will always ask for even quantities
-- so that the price count is always an integer number
local amount_to_buy = math.random(buyable_items[item].min_buyable_item_count, buyable_items[item].max_buyable_item_count)
-- Create trade offer
--minetest.log("Buyable item: "..dump(buyable_items[item]))
result = npc.trade.create_offer(npc.trade.OFFER_BUY, item, buyable_items[item].price, buyable_items[item].min_buyable_item_price, amount_to_buy)
else
-- Make sell offer, NPC will sell items to player at regular price
-- NPC will also offer items from their inventory
local sellable_items = {}
for i = 1, #self.inventory do
if self.inventory[i] ~= "" then
if npc.trade.prices.is_item_currency(self.inventory[i]) == false then
table.insert(sellable_items, self.inventory[i])
end
end
end
-- Check if there are no sellable items to avoid crash
if #sellable_items > 0 then
-- Choose a random item from the sellable items
local item = sellable_items[math.random(#sellable_items)]
-- Choose how many of this item will be sold to player
local count = math.random(npc.get_item_count(item))
-- Create trade offer
result = npc.trade.create_offer(npc.trade.OFFER_SELL, npc.get_item_name(item), nil, nil, count)
end
end
return result
end
-- The following function create buy and sell offers for dedicated traders,
-- based on the trader list and the source of items. Initially, it will only
-- be NPC inventories. In the future, it should support both NPC and chest
-- inventories,
function npc.trade.get_dedicated_trade_offers(self)
local offers = {
sell = {},
buy = {}
}
local trade_list = self.trader_data.trade_list
--npc.log("INFO", "NPC Inventory: "..dump(self.inventory))
for item_name, trade_info in pairs(trade_list) do
-- Abort if more than 12 buy or sell offers are made
if table.getn(offers.sell) >= 12 or table.getn(offers.buy) >= 12 then
break
end
-- For each item on the trader list, check if it is in the NPC inventory.
-- If it is, create a sell offer, else create a buy offer if possible.
-- Also, avoid creating sell offers immediately if the item was just bought
local item = npc.inventory_contains(self, item_name)
--minetest.log("Searched item: "..dump(item_name))
--minetest.log("Found: "..dump(item))
if item ~= nil and trade_info.last_offer_type ~= npc.trade.OFFER_BUY then
-- Check if item can be sold
if trade_info.item_sold_count == nil
or (trade_info.item_sold_count ~= nil
and (trade_info.max_item_sell_count
and trade_info.item_sold_count < trade_info.max_item_sell_count)) then
-- This check makes sure that the NPC will keep max_item_sell_count at any time.
if trade_info.amount_to_keep == nil or (trade_info.amount_to_keep ~= nil
and trade_info.amount_to_keep < ItemStack(item.item_string):get_count()) then
-- Create sell offer for this item. Currently, traders will offer to sell only
-- one of their items to allow the fine control for players to buy what they want.
-- This requires, however, that the trade offers are re-generated everytime a
-- sell is made.
table.insert(offers.sell, npc.trade.create_offer(
npc.trade.OFFER_SELL,
item_name,
nil,
nil,
1)
)
-- Set last offer type
trade_info.last_offer_type = npc.trade.OFFER_SELL
end
else
-- Clear the trade info for this item
trade_info.item_sold_count = 0
end
else
-- Avoid flipping an item to the buy side if the stock was just depleted
if trade_info.last_offer_type ~= npc.trade.OFFER_SELL then
-- Create buy offer for this item
-- Only do if the NPC can actually afford the items.
local currencies = npc.trade.get_currencies_in_inventory(self)
-- Check if currency isn't empty
if #currencies > 0 then
-- Choose a random currency
local chosen_tier = currencies[math.random(#currencies)]
-- Get items for this currency
local buyable_items =
npc.trade.prices.get_items_for_currency_count(chosen_tier.name, chosen_tier.count, 0.5)
-- Check if the item from trader list is present in the buyable items list
for buyable_item, price_info in pairs(buyable_items) do
if buyable_item == item_name then
-- If item found, create a buy offer for this item
-- Again, offers are created for one item only. Buy offers should be removed
-- after the NPC has bought a certain quantity, say, 5 items.
if trade_info.item_bought_count == nil
or (trade_info.item_bought_count ~= nil
and (trade_info.max_item_buy_count and trade_info.item_bought_count <= trade_info.max_item_buy_count
or trade_info.item_bought_count <= npc.trade.DEDICATED_MAX_BUY_AMOUNT)) then
-- Create trade offer for this item
table.insert(offers.buy, npc.trade.create_offer(
npc.trade.OFFER_BUY,
item_name,
price_info.price,
price_info.min_buyable_item_price,
price_info.min_buyable_item_count)
)
-- Set last offer type
trade_info.last_offer_type = npc.trade.OFFER_BUY
else
-- Clear the trade info for this item
trade_info.item_bought_count = 0
end
end
end
end
end
end
end
return offers
end
-- Creates a trade offer based on the offer type, given item and count. If
-- the offer is a "buy" offer, it is required to provide the price item and
-- the minimum price item count.
function npc.trade.create_offer(offer_type, item, price, min_price_item_count, count)
local result = {}
-- Check offer type
if offer_type == npc.trade.OFFER_BUY then
-- Get price for the given item
-- Create price itemstring
local price_string = price.tier.." "
..tostring( min_price_item_count * count )
-- Build the return object
-- Price is always an array, in this case of size 1
result = {
offer_type = offer_type,
item = item.." "..count,
price = {[1] = price_string}
}
else
-- Make sell offer, NPC will sell items to player at regular price
-- Get and calculate price for this object
local price_object = npc.trade.prices.table[item]
-- Check price object, if price < 1 then offer to sell for 1
if price_object.count < 1 then
price_object.count = 1
end
local price_string = price_object.tier.." "..tostring(price_object.count * count)
-- Build return object
-- Price is always an array, in this case of size 1
result = {
offer_type = offer_type,
item = npc.get_item_name(item).." "..count,
price = {[1] = price_string}
}
end
return result
end
-- A custom sell trade offer is a special type of trading the NPC can
-- have where a different prompt and multiple payment objects are
-- required from the player. A good example is offering to repair a sword,
-- where the player has to give an amount of currency and the sword to
-- repair in exchange to get a fully repaired sword.
-- For the moment being, only sell is supported.
function npc.trade.create_custom_sell_trade_offer(option_prompt, dialogue_prompt, button_prompt, item, payments)
return {
offer_type = npc.OFFER_SELL,
option_prompt = option_prompt,
dialogue_prompt = dialogue_prompt,
button_prompt = button_prompt,
item = item,
price = payments
}
end
-- TODO: This method needs to be refactored to be able to manage
-- both NPC inventories and chest inventories.
-- Returns true if trade was possible, else returns false.
function npc.trade.perform_trade(self, player_name, offer)
local item_stack = ItemStack(offer.item)
-- Create item stacks for each price item
local price_stacks = {}
for i = 1, #offer.price do
table.insert(price_stacks, ItemStack(offer.price[i]))
end
local inv = minetest.get_inventory({type = "player", name = player_name})
-- Check if offer is a buy or sell
if offer.offer_type == npc.trade.OFFER_BUY then
-- If NPC is buying from player, then player loses item, gets price
-- Check player has the item being buyed
if inv:contains_item("main", item_stack) then
-- Check if there is enough room to add the price item to player
for i = 1, #price_stacks do
if inv:room_for_item("main", price_stacks[i]) then
-- Remove item from player
inv:remove_item("main", item_stack)
-- Remove price item(s) from NPC
for j = 1, #price_stacks do
npc.take_item_from_inventory_itemstring(self, price_stacks[j])
end
-- Add item to NPC's inventory
npc.add_item_to_inventory_itemstring(self, offer.item)
-- Add price items to player
for j = 1, #price_stacks do
inv:add_item("main", price_stacks[j])
end
-- Send message to player
npc.chat(self.npc_name, player_name, "Thank you!")
return true
else
npc.chat(self.npc_name, player_name,
"Looks like you can't get what I'm giving you for payment!")
return false
end
end
else
npc.chat(self.npc_name, player_name,
"Looks like you don't have what I want to buy...")
return false
end
else
-- If NPC is selling to the player, then player gives price and gets
-- item, NPC loses item and gets price.
for i = 1, #price_stacks do
-- Check NPC has the required item to pay
if inv:contains_item("main", price_stacks[i]) then
-- Check if there is enough room to add the item to player
if inv:room_for_item("main", item_stack) then
-- Remove price item from player
for j = 1, #price_stacks do
inv:remove_item("main", price_stacks[j])
end
-- Remove sell item from NPC
npc.take_item_from_inventory_itemstring(self, offer.item)
-- Add price to NPC's inventory
for i = 1, #offer.price do
npc.add_item_to_inventory_itemstring(self, offer.price[i])
end
-- Add item items to player
inv:add_item("main", item_stack)
-- Send message to player
npc.chat(self.npc_name, player_name, "Thank you!")
return true
else
npc.chat(self.npc_name, player_name,
"Looks like you can't carry anything else...")
return false
end
else
npc.chat(self.npc_name, player_name,
"Looks like you don't have what I'm asking for!")
return false
end
end
end
end
-- Handler for chat formspec
minetest.register_on_player_receive_fields(function (player, formname, fields)
-- Additional checks for other forms should be handled here
-- Handle casual trade dialogue
if formname == "advanced_npc:trade_offer" then
local player_name = player:get_player_name()
if fields then
local player_response = npc.trade.results.single_trade_offer[player_name]
-- Unlock the action timer
npc.unlock_actions(player_response.npc)
if fields.yes_option then
npc.trade.perform_trade(player_response.npc, player_name, player_response.trade_offer)
elseif fields.no_option then
minetest.chat_send_player(player_name, "Talk to me if you change your mind!")
end
end
elseif formname == "advanced_npc:dedicated_trading_offers" then
local player_name = player:get_player_name()
if fields then
local player_response = npc.trade.results.trade_offers[player_name]
-- Unlock the action timer
npc.unlock_actions(player_response.npc)
local trade_offers = npc.trade.results.trade_offers[player_name].offers
-- Check which price was clicked
for i = 1, #trade_offers do
local price_button = "price"..tostring(i)
if fields[price_button] then
local trade_result = npc.trade.perform_trade(player_response.npc, player_name, trade_offers[i])
if trade_result == true then
-- Lock actions
npc.lock_actions(player_response.npc)
-- Account for buyed items
if player_response.offers_type == npc.trade.OFFER_BUY then
-- Increase the item bought count
local offer_item_name = npc.get_item_name(trade_offers[i].item)
--minetest.log("Bought item name: "..dump(offer_item_name))
--minetest.log(dump(player_response.npc.trader_data.trade_list[offer_item_name]))
-- Check if this item has been bought before
if player_response.npc.trader_data.trade_list[offer_item_name].item_bought_count == nil then
-- Set first count to 1
player_response.npc.trader_data.trade_list[offer_item_name].item_bought_count = 1
else
-- Increase count
player_response.npc.trader_data.trade_list[offer_item_name].item_bought_count
= player_response.npc.trader_data.trade_list[offer_item_name].item_bought_count + 1
end
else
-- Also count how many items are sold
local offer_item_name = npc.get_item_name(trade_offers[i].item)
-- Check if this item has been sold before
if player_response.npc.trader_data.trade_list[offer_item_name].item_sold_count == nil then
-- Set first count to 1
player_response.npc.trader_data.trade_list[offer_item_name].item_sold_count = 1
else
-- Increase count
player_response.npc.trader_data.trade_list[offer_item_name].item_sold_count
= player_response.npc.trader_data.trade_list[offer_item_name].item_sold_count + 1
end
end
-- Re-generate trade offers
npc.trade.generate_trade_offers_by_status(player_response.npc)
-- Show refreshed formspec again to player
npc.trade.show_dedicated_trade_formspec(player_response.npc, player, player_response.offers_type)
return true
else
minetest.close_formspec(player_name, "advanced_npc:dedicated_trading_offers")
return false
end
--minetest.log("Player selected: "..dump(trade_offers[i]))
end
end
end
elseif formname == "advanced_npc:custom_trade_offer" then
-- Handle custom trade formspec
local player_name = player:get_player_name()
if fields then
local player_response = npc.trade.results.custom_trade_offer[player_name]
-- Unlock the action timer
npc.unlock_actions(player_response.npc)
if fields.yes_option then
npc.trade.perform_trade(player_response.npc, player_name, player_response.trade_offer)
elseif fields.no_option then
minetest.chat_send_player(player_name, "Talk to me if you change your mind!")
end
end
end
end)
Reference in New Issue View Git Blame Copy Permalink