e79fb91ff3
Relationships: Re-write to the way favorite/disliked items are defined, now allow Minetest's like registration as well. Random data: Random data now includes registrations for gift items and dialogues.
1286 lines
41 KiB
Lua
Executable File
1286 lines
41 KiB
Lua
Executable File
-- Advanced NPC by Zorman2000
|
|
-- Based on original NPC by Tenplus1
|
|
|
|
local S = mobs.intllib
|
|
|
|
npc = {}
|
|
|
|
-- Constants
|
|
npc.FEMALE = "female"
|
|
npc.MALE = "male"
|
|
|
|
npc.age = {
|
|
adult = "adult",
|
|
child = "child"
|
|
}
|
|
|
|
npc.INVENTORY_ITEM_MAX_STACK = 99
|
|
|
|
npc.ANIMATION_STAND_START = 0
|
|
npc.ANIMATION_STAND_END = 79
|
|
npc.ANIMATION_SIT_START = 81
|
|
npc.ANIMATION_SIT_END = 160
|
|
npc.ANIMATION_LAY_START = 162
|
|
npc.ANIMATION_LAY_END = 166
|
|
npc.ANIMATION_WALK_START = 168
|
|
npc.ANIMATION_WALK_END = 187
|
|
|
|
npc.direction = {
|
|
north = 0,
|
|
east = 1,
|
|
south = 2,
|
|
west = 3,
|
|
north_east = 4,
|
|
north_west = 5,
|
|
south_east = 6,
|
|
south_west = 7
|
|
}
|
|
|
|
npc.action_state = {
|
|
none = 0,
|
|
executing = 1,
|
|
interrupted = 2
|
|
}
|
|
|
|
npc.log_level = {
|
|
INFO = true,
|
|
WARNING = true,
|
|
ERROR = true,
|
|
DEBUG = false
|
|
}
|
|
|
|
npc.texture_check = {
|
|
timer = 0,
|
|
interval = 2
|
|
}
|
|
|
|
---------------------------------------------------------------------------------------
|
|
-- General functions
|
|
---------------------------------------------------------------------------------------
|
|
-- Logging
|
|
function npc.log(level, message)
|
|
if npc.log_level[level] then
|
|
minetest.log("[advanced_npc] "..level..": "..message)
|
|
end
|
|
end
|
|
|
|
-- NPC chat
|
|
function npc.chat(npc_name, player_name, message)
|
|
minetest.chat_send_player(player_name, npc_name..": "..message)
|
|
end
|
|
|
|
-- Gets name of player or NPC
|
|
function npc.get_entity_name(entity)
|
|
if entity:is_player() then
|
|
return entity:get_player_name()
|
|
else
|
|
return entity:get_luaentity().name
|
|
end
|
|
end
|
|
|
|
-- Returns the item "wielded" by player or NPC
|
|
-- TODO: Implement NPC
|
|
function npc.get_entity_wielded_item(entity)
|
|
if entity:is_player() then
|
|
return entity:get_wielded_item()
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------
|
|
-- Spawning functions
|
|
---------------------------------------------------------------------------------------
|
|
-- These functions are used at spawn time to determine several
|
|
-- random attributes for the NPC in case they are not already
|
|
-- defined. On a later phase, pre-defining many of the NPC values
|
|
-- will be allowed.
|
|
|
|
local function get_random_name(sex)
|
|
local i = math.random(#npc.data.FIRST_NAMES[sex])
|
|
return npc.data.FIRST_NAMES[sex][i]
|
|
end
|
|
|
|
local function initialize_inventory()
|
|
return {
|
|
[1] = "", [2] = "", [3] = "", [4] = "",
|
|
[5] = "", [6] = "", [7] = "", [8] = "",
|
|
[9] = "", [10] = "", [11] = "", [12] = "",
|
|
[13] = "", [14] = "", [15] = "", [16] = "",
|
|
}
|
|
end
|
|
|
|
-- This function checks for "female" text on the texture name
|
|
local function is_female_texture(textures)
|
|
for i = 1, #textures do
|
|
if string.find(textures[i], "female") ~= nil then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
local function get_random_texture(sex, age)
|
|
local textures = {}
|
|
local filtered_textures = {}
|
|
-- Find textures by sex and age
|
|
if age == npc.age.adult then
|
|
--minetest.log("Registered: "..dump(minetest.registered_entities["advanced_npc:npc"]))
|
|
textures = minetest.registered_entities["advanced_npc:npc"].texture_list
|
|
elseif age == npc.age.child then
|
|
textures = minetest.registered_entities["advanced_npc:npc"].child_texture
|
|
end
|
|
|
|
for i = 1, #textures do
|
|
local current_texture = textures[i][1]
|
|
if (sex == npc.MALE
|
|
and string.find(current_texture, sex)
|
|
and not string.find(current_texture, npc.FEMALE))
|
|
or (sex == npc.FEMALE
|
|
and string.find(current_texture, sex)) then
|
|
table.insert(filtered_textures, current_texture)
|
|
end
|
|
end
|
|
|
|
-- Check if filtered textures is empty
|
|
if filtered_textures == {} then
|
|
return textures[1][1]
|
|
end
|
|
|
|
return filtered_textures[math.random(1,#filtered_textures)]
|
|
end
|
|
|
|
function npc.get_random_texture_from_array(age, sex, textures)
|
|
local filtered_textures = {}
|
|
|
|
for i = 1, #textures do
|
|
local current_texture = textures[i]
|
|
-- Filter by age
|
|
if (sex == npc.MALE
|
|
and string.find(current_texture, sex)
|
|
and not string.find(current_texture, npc.FEMALE)
|
|
and ((age == npc.age.adult
|
|
and not string.find(current_texture, npc.age.child))
|
|
or (age == npc.age.child
|
|
and string.find(current_texture, npc.age.child))
|
|
)
|
|
)
|
|
or (sex == npc.FEMALE
|
|
and string.find(current_texture, sex)
|
|
and ((age == npc.age.adult
|
|
and not string.find(current_texture, npc.age.child))
|
|
or (age == npc.age.child
|
|
and string.find(current_texture, npc.age.child))
|
|
)
|
|
) then
|
|
table.insert(filtered_textures, current_texture)
|
|
end
|
|
end
|
|
|
|
return filtered_textures[math.random(1, #filtered_textures)]
|
|
end
|
|
|
|
-- Choose whether NPC can have relationships. Only 30% of NPCs
|
|
-- cannot have relationships
|
|
local function can_have_relationships(is_child)
|
|
-- Children can't have relationships
|
|
if is_child then
|
|
return false
|
|
end
|
|
local chance = math.random(1,10)
|
|
return chance > 3
|
|
end
|
|
|
|
-- Choose a maximum of two items that the NPC will have at spawn time
|
|
-- These items are chosen from the favorite items list.
|
|
local function choose_spawn_items(self)
|
|
local number_of_items_to_add = math.random(1, 2)
|
|
local number_of_items = #npc.FAVORITE_ITEMS[self.sex].phase1
|
|
|
|
for i = 1, number_of_items_to_add do
|
|
npc.add_item_to_inventory(
|
|
self,
|
|
npc.FAVORITE_ITEMS[self.sex].phase1[math.random(1, number_of_items)].item,
|
|
math.random(1,5)
|
|
)
|
|
end
|
|
-- Add currency to the items spawned with. Will add 5-10 tier 3
|
|
-- currency items
|
|
local currency_item_count = math.random(5, 10)
|
|
npc.add_item_to_inventory(self, npc.trade.prices.currency.tier3.string, currency_item_count)
|
|
|
|
-- For test
|
|
--npc.add_item_to_inventory(self, "default:tree", 10)
|
|
--npc.add_item_to_inventory(self, "default:cobble", 10)
|
|
--npc.add_item_to_inventory(self, "default:diamond", 2)
|
|
--npc.add_item_to_inventory(self, "default:mese_crystal", 2)
|
|
--npc.add_item_to_inventory(self, "flowers:rose", 2)
|
|
--npc.add_item_to_inventory(self, "advanced_npc:marriage_ring", 2)
|
|
--npc.add_item_to_inventory(self, "flowers:geranium", 2)
|
|
--npc.add_item_to_inventory(self, "mobs:meat", 2)
|
|
--npc.add_item_to_inventory(self, "mobs:leather", 2)
|
|
--npc.add_item_to_inventory(self, "default:sword_stone", 2)
|
|
--npc.add_item_to_inventory(self, "default:shovel_stone", 2)
|
|
--npc.add_item_to_inventory(self, "default:axe_stone", 2)
|
|
|
|
--minetest.log("Initial inventory: "..dump(self.inventory))
|
|
end
|
|
|
|
-- Spawn function. Initializes all variables that the
|
|
-- NPC will have and choose random, starting values
|
|
function npc.initialize(entity, pos, is_lua_entity, npc_stats)
|
|
npc.log("INFO", "Initializing NPC at "..minetest.pos_to_string(pos))
|
|
|
|
-- Get variables
|
|
local ent = entity
|
|
if not is_lua_entity then
|
|
ent = entity:get_luaentity()
|
|
end
|
|
|
|
-- Avoid NPC to be removed by mobs_redo API
|
|
ent.remove_ok = false
|
|
|
|
-- Determine sex and age
|
|
-- If there's no previous NPC data, sex and age will be randomly chosen.
|
|
-- - Sex: Female or male will have each 50% of spawning
|
|
-- - Age: 90% chance of spawning adults, 10% chance of spawning children.
|
|
-- If there is previous data then:
|
|
-- - Sex: The unbalanced sex will get a 75% chance of spawning
|
|
-- - Example: If there's one male, then female will have 75% spawn chance.
|
|
-- - If there's male and female, then each have 50% spawn chance.
|
|
-- - Age: For each two adults, the chance of spawning a child next will be 50%
|
|
-- If there's a child for two adults, the chance of spawning a child goes to
|
|
-- 40% and keeps decreasing unless two adults have no child.
|
|
if npc_stats then
|
|
-- Default chances
|
|
local male_s, male_e = 0, 50
|
|
local female_s, female_e = 51, 100
|
|
local adult_s, adult_e = 0, 90
|
|
local child_s, child_e = 91, 100
|
|
-- Determine sex probabilities
|
|
if npc_stats[npc.FEMALE].total > npc_stats[npc.MALE].total then
|
|
male_e = 75
|
|
female_s, female_e = 76, 100
|
|
elseif npc_stats[npc.FEMALE].total < npc_stats[npc.MALE].total then
|
|
male_e = 25
|
|
female_s, female_e = 26, 100
|
|
end
|
|
-- Determine age probabilities
|
|
if npc_stats["adult_total"] >= 2 then
|
|
if npc_stats["adult_total"] % 2 == 0
|
|
and (npc_stats["adult_total"] / 2 > npc_stats["child_total"]) then
|
|
child_s,child_e = 26, 100
|
|
adult_e = 25
|
|
else
|
|
child_s, child_e = 61, 100
|
|
adult_e = 60
|
|
end
|
|
end
|
|
-- Get sex and age based on the probabilities
|
|
local sex_chance = math.random(1, 100)
|
|
local age_chance = math.random(1, 100)
|
|
local selected_sex = ""
|
|
local selected_age = ""
|
|
-- Select sex
|
|
if male_s <= sex_chance and sex_chance <= male_e then
|
|
selected_sex = npc.MALE
|
|
elseif female_s <= sex_chance and sex_chance <= female_e then
|
|
selected_sex = npc.FEMALE
|
|
end
|
|
-- Set sex for NPC
|
|
ent.sex = selected_sex
|
|
-- Select age
|
|
if adult_s <= age_chance and age_chance <= adult_e then
|
|
selected_age = npc.age.adult
|
|
elseif child_s <= age_chance and age_chance <= child_e then
|
|
selected_age = npc.age.child
|
|
ent.visual_size = {
|
|
x = 0.60,
|
|
y = 0.60
|
|
}
|
|
ent.collisionbox = {-0.10,-0.50,-0.10, 0.10,0.40,0.10}
|
|
ent.is_child = true
|
|
-- For mobs_redo
|
|
ent.child = true
|
|
end
|
|
-- Store the selected age
|
|
ent.age = selected_age
|
|
|
|
-- Set texture accordingly
|
|
local selected_texture = get_random_texture(selected_sex, selected_age)
|
|
--minetest.log("Selected texture: "..dump(selected_texture))
|
|
-- Store selected texture due to the need to restore it later
|
|
ent.selected_texture = selected_texture
|
|
-- Set texture and base texture
|
|
ent.textures = {selected_texture}
|
|
ent.base_texture = {selected_texture}
|
|
else
|
|
-- Get sex based on texture. This is a 50% chance for
|
|
-- each sex as there's same amount of textures for male and female.
|
|
-- Do not spawn child as first NPC
|
|
if (is_female_texture(ent.base_texture)) then
|
|
ent.sex = npc.FEMALE
|
|
else
|
|
ent.sex = npc.MALE
|
|
end
|
|
end
|
|
|
|
-- Nametag is initialized to blank
|
|
ent.nametag = ""
|
|
|
|
-- Set name
|
|
ent.npc_name = get_random_name(ent.sex)
|
|
|
|
-- Set ID
|
|
ent.npc_id = tostring(math.random(1000, 9999))..":"..ent.npc_name
|
|
|
|
-- Initialize all gift data
|
|
ent.gift_data = {
|
|
-- Choose favorite items. Choose phase1 per default
|
|
favorite_items = npc.relationships.select_random_favorite_items(ent.sex, "phase1"),
|
|
-- Choose disliked items. Choose phase1 per default
|
|
disliked_items = npc.relationships.select_random_disliked_items(ent.sex),
|
|
}
|
|
|
|
-- Flag that determines if NPC can have a relationship
|
|
ent.can_have_relationship = can_have_relationships(ent.is_child)
|
|
|
|
--ent.infotext = "Interested in relationships: "..dump(ent.can_have_relationship)
|
|
|
|
-- Flag to determine if NPC can receive gifts
|
|
ent.can_receive_gifts = ent.can_have_relationship
|
|
|
|
-- Initialize relationships object
|
|
ent.relationships = {}
|
|
|
|
-- Determines if NPC is married or not
|
|
ent.is_married_to = nil
|
|
|
|
-- Initialize dialogues
|
|
ent.dialogues = npc.dialogue.select_random_dialogues_for_npc(ent, "phase1")
|
|
|
|
-- Declare NPC inventory
|
|
ent.inventory = initialize_inventory()
|
|
|
|
-- Choose items to spawn with
|
|
choose_spawn_items(ent)
|
|
|
|
-- Flags: generic booleans or functions that help drive functionality
|
|
ent.flags = {}
|
|
|
|
-- Declare trade data
|
|
ent.trader_data = {
|
|
-- Type of trader
|
|
trader_status = npc.trade.get_random_trade_status(),
|
|
-- Current buy offers
|
|
buy_offers = {},
|
|
-- Current sell offers
|
|
sell_offers = {},
|
|
-- Items to buy change timer
|
|
change_offers_timer = 0,
|
|
-- Items to buy change timer interval
|
|
change_offers_timer_interval = 60,
|
|
-- Trading list: a list of item names the trader is expected to trade in.
|
|
-- It is mostly related to its occupation.
|
|
-- If empty, the NPC will revert to casual trading
|
|
-- If not, it will try to sell those that it have, and buy the ones it not.
|
|
trade_list = {
|
|
sell = {},
|
|
buy = {},
|
|
both = {}
|
|
},
|
|
-- Custom trade allows to specify more than one payment
|
|
-- and a custom prompt (instead of the usual buy or sell prompts)
|
|
custom_trades = {}
|
|
}
|
|
|
|
-- Initialize trading offers for NPC
|
|
--npc.trade.generate_trade_offers_by_status(ent)
|
|
-- if ent.trader_data.trader_status == npc.trade.CASUAL then
|
|
-- select_casual_trade_offers(ent)
|
|
-- end
|
|
|
|
-- Actions data
|
|
ent.actions = {
|
|
-- The queue is a queue of actions to be performed on each interval
|
|
queue = {},
|
|
-- Current value of the action timer
|
|
action_timer = 0,
|
|
-- Determines the interval for each action in the action queue
|
|
-- Default is 1. This can be changed via actions
|
|
action_interval = 1,
|
|
-- Avoid the execution of the action timer
|
|
action_timer_lock = false,
|
|
-- Defines the state of the current action
|
|
current_action_state = npc.action_state.none,
|
|
-- Store information about action on state before lock
|
|
state_before_lock = {
|
|
-- State of the mobs_redo API
|
|
freeze = false,
|
|
-- State of execution
|
|
action_state = npc.action_state.none,
|
|
-- Action executed while on lock
|
|
interrupted_action = {}
|
|
},
|
|
-- Walking variables -- required for implementing accurate movement code
|
|
walking = {
|
|
-- Defines whether NPC is walking to specific position or not
|
|
is_walking = false,
|
|
-- Path that the NPC is following
|
|
path = {},
|
|
-- Target position the NPC is supposed to walk to in this step. NOTE:
|
|
-- This is NOT the end of the path, but the next position in the path
|
|
-- relative to the last position
|
|
target_pos = {}
|
|
}
|
|
}
|
|
|
|
-- This flag is checked on every step. If it is true, the rest of
|
|
-- Mobs Redo API is not executed
|
|
ent.freeze = nil
|
|
|
|
-- This map will hold all the places for the NPC
|
|
-- Map entries should be like: "bed" = {x=1, y=1, z=1}
|
|
ent.places_map = {}
|
|
|
|
-- Schedule data
|
|
ent.schedules = {
|
|
-- Flag to enable or disable the schedules functionality
|
|
enabled = true,
|
|
-- Lock for when executing a schedule
|
|
lock = false,
|
|
-- Queue of schedules executed
|
|
-- Used to calculate dependencies
|
|
temp_executed_queue = {},
|
|
-- An array of schedules, meant to be one per day at some point
|
|
-- when calendars are implemented. Allows for only 7 schedules,
|
|
-- one for each day of the week
|
|
generic = {},
|
|
-- An array of schedules, meant to be for specific dates in the
|
|
-- year. Can contain as many as possible. The keys will be strings
|
|
-- in the format MM:DD
|
|
date_based = {}
|
|
}
|
|
|
|
-- Dedicated trade test
|
|
ent.trader_data.trade_list.both = {
|
|
["default:tree"] = {},
|
|
["default:cobble"] = {},
|
|
["default:wood"] = {},
|
|
["default:diamond"] = {},
|
|
["default:mese_crystal"] = {},
|
|
["flowers:rose"] = {},
|
|
["advanced_npc:marriage_ring"] = {},
|
|
["flowers:geranium"] = {},
|
|
["mobs:meat"] = {},
|
|
["mobs:leather"] = {},
|
|
["default:sword_stone"] = {},
|
|
["default:shovel_stone"] = {},
|
|
["default:axe_stone"] = {}
|
|
}
|
|
|
|
npc.trade.generate_trade_offers_by_status(ent)
|
|
|
|
-- Add a custom trade offer
|
|
local offer1 = npc.trade.create_custom_sell_trade_offer("Do you want me to fix your steel sword?", "Fix steel sword", "Fix steel sword", "default:sword_steel", {"default:sword_steel", "default:iron_lump 5"})
|
|
table.insert(ent.trader_data.custom_trades, offer1)
|
|
local offer2 = npc.trade.create_custom_sell_trade_offer("Do you want me to fix your mese sword?", "Fix mese sword", "Fix mese sword", "default:sword_mese", {"default:sword_mese", "default:copper_lump 10"})
|
|
table.insert(ent.trader_data.custom_trades, offer2)
|
|
|
|
ent.initialized = true
|
|
--minetest.log(dump(ent))
|
|
npc.log("INFO", "Successfully initialized NPC with name "..dump(ent.npc_name)
|
|
..", sex: "..ent.sex..", is child: "..dump(ent.is_child)
|
|
..", texture: "..dump(ent.textures))
|
|
-- Refreshes entity
|
|
ent.object:set_properties(ent)
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------
|
|
-- Trading functions
|
|
---------------------------------------------------------------------------------------
|
|
function npc.generate_trade_list_from_inventory(self)
|
|
local list = {}
|
|
for i = 1, #self.inventory do
|
|
list[npc.get_item_name(self.inventory[i])] = {}
|
|
end
|
|
self.trader_data.trade_list.both = list
|
|
end
|
|
|
|
function npc.set_trading_status(self, status)
|
|
-- Set status
|
|
self.trader_data.trader_status = status
|
|
-- Re-generate trade offers
|
|
npc.trade.generate_trade_offers_by_status(self)
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------
|
|
-- Inventory functions
|
|
---------------------------------------------------------------------------------------
|
|
-- NPCs inventories are restrained to 16 slots.
|
|
-- Each slot can hold one item up to 99 count.
|
|
|
|
-- Utility function to get item name from a string
|
|
function npc.get_item_name(item_string)
|
|
return ItemStack(item_string):get_name()
|
|
end
|
|
|
|
-- Utility function to get item count from a string
|
|
function npc.get_item_count(item_string)
|
|
return ItemStack(item_string):get_count()
|
|
end
|
|
|
|
-- Add an item to inventory. Returns true if add successful
|
|
-- These function can be used to give items to other NPCs
|
|
-- given that the "self" variable can be any NPC
|
|
function npc.add_item_to_inventory(self, item_name, count)
|
|
-- Check if NPC already has item
|
|
local existing_item = npc.inventory_contains(self, item_name)
|
|
if existing_item ~= nil and existing_item.item_string ~= nil then
|
|
-- NPC already has item. Get count and see
|
|
local existing_count = npc.get_item_count(existing_item.item_string)
|
|
if (existing_count + count) < npc.INVENTORY_ITEM_MAX_STACK then
|
|
-- Set item here
|
|
self.inventory[existing_item.slot] =
|
|
npc.get_item_name(existing_item.item_string).." "..tostring(existing_count + count)
|
|
return true
|
|
else
|
|
--Find next free slot
|
|
for i = 1, #self.inventory do
|
|
if self.inventory[i] == "" then
|
|
-- Found slot, set item
|
|
self.inventory[i] =
|
|
item_name.." "..tostring((existing_count + count) - npc.INVENTORY_ITEM_MAX_STACK)
|
|
return true
|
|
end
|
|
end
|
|
-- No free slot found
|
|
return false
|
|
end
|
|
else
|
|
-- Find a free slot
|
|
for i = 1, #self.inventory do
|
|
if self.inventory[i] == "" then
|
|
-- Found slot, set item
|
|
self.inventory[i] = item_name.." "..tostring(count)
|
|
return true
|
|
end
|
|
end
|
|
-- No empty slot found
|
|
return false
|
|
end
|
|
end
|
|
|
|
-- Same add method but with itemstring for convenience
|
|
function npc.add_item_to_inventory_itemstring(self, item_string)
|
|
local item_name = npc.get_item_name(item_string)
|
|
local item_count = npc.get_item_count(item_string)
|
|
npc.add_item_to_inventory(self, item_name, item_count)
|
|
end
|
|
|
|
-- Checks if an item is contained in the inventory. Returns
|
|
-- the item string or nil if not found
|
|
function npc.inventory_contains(self, item_name)
|
|
for key,value in pairs(self.inventory) do
|
|
if value ~= "" and string.find(value, item_name) then
|
|
return {slot=key, item_string=value}
|
|
end
|
|
end
|
|
-- Item not found
|
|
return nil
|
|
end
|
|
|
|
-- Removes the item from an NPC inventory and returns the item
|
|
-- with its count (as a string, e.g. "default:apple 2"). Returns
|
|
-- nil if unable to get the item.
|
|
function npc.take_item_from_inventory(self, item_name, count)
|
|
local existing_item = npc.inventory_contains(self, item_name)
|
|
if existing_item ~= nil then
|
|
-- Found item
|
|
local existing_count = npc.get_item_count(existing_item.item_string)
|
|
local new_count = existing_count
|
|
if existing_count - count < 0 then
|
|
-- Remove item first
|
|
self.inventory[existing_item.slot] = ""
|
|
-- TODO: Support for retrieving from next stack. Too complicated
|
|
-- and honestly might be unecessary.
|
|
return item_name.." "..tostring(new_count)
|
|
else
|
|
new_count = existing_count - count
|
|
if new_count == 0 then
|
|
self.inventory[existing_item.slot] = ""
|
|
else
|
|
self.inventory[existing_item.slot] = item_name.." "..new_count
|
|
end
|
|
return item_name.." "..tostring(count)
|
|
end
|
|
else
|
|
-- Not able to take item because not found
|
|
return nil
|
|
end
|
|
end
|
|
|
|
-- Same take method but with itemstring for convenience
|
|
function npc.take_item_from_inventory_itemstring(self, item_string)
|
|
local item_name = npc.get_item_name(item_string)
|
|
local item_count = npc.get_item_count(item_string)
|
|
npc.take_item_from_inventory(self, item_name, item_count)
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------
|
|
-- Flag functionality
|
|
---------------------------------------------------------------------------------------
|
|
-- TODO: Consider removing them as they are pretty simple and straight forward.
|
|
-- Generic variables or function that help drive some functionality for the NPC.
|
|
function npc.add_flag(self, flag_name, value)
|
|
self.flags[flag_name] = value
|
|
end
|
|
|
|
function npc.update_flag(self, flag_name, value)
|
|
self.flags[flag_name] = value
|
|
end
|
|
|
|
function npc.get_flag(self, flag_name)
|
|
return self.flags[flag_name]
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------
|
|
-- Dialogue functionality
|
|
---------------------------------------------------------------------------------------
|
|
function npc.start_dialogue(self, clicker, show_married_dialogue)
|
|
|
|
-- Call dialogue function as normal
|
|
npc.dialogue.start_dialogue(self, clicker, show_married_dialogue)
|
|
|
|
-- Check and update relationship if needed
|
|
npc.relationships.dialogue_relationship_update(self, clicker)
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------
|
|
-- Action functionality
|
|
---------------------------------------------------------------------------------------
|
|
-- This function adds a function to the action queue.
|
|
-- Actions should be added in strict order for tasks to work as expected.
|
|
function npc.add_action(self, action, arguments)
|
|
local action_entry = {action=action, args=arguments, is_task=false}
|
|
table.insert(self.actions.queue, action_entry)
|
|
end
|
|
|
|
-- This function adds task actions in-place, as opposed to
|
|
-- at the end of the queue. This allows for continued order
|
|
function npc.add_task(self, task, args)
|
|
local action_entry = {action=task, args=args, is_task=true}
|
|
table.insert(self.actions.queue, action_entry)
|
|
end
|
|
|
|
-- This function removes the first action in the action queue
|
|
-- and then executes it
|
|
function npc.execute_action(self)
|
|
-- Check if an action was interrupted
|
|
if self.actions.current_action_state == npc.action_state.interrupted then
|
|
npc.log("DEBUG", "Re-inserting interrupted action for NPC: '"..dump(self.npc_name).."': "..dump(self.actions.state_before_lock.interrupted_action))
|
|
-- Insert into queue the interrupted action
|
|
table.insert(self.actions.queue, 1, self.actions.state_before_lock.interrupted_action)
|
|
-- Clear the action
|
|
self.actions.state_before_lock.interrupted_action = {}
|
|
-- Clear the position
|
|
self.actions.state_before_lock.pos = {}
|
|
end
|
|
local result = nil
|
|
if table.getn(self.actions.queue) == 0 then
|
|
-- Set state to none
|
|
self.actions.current_action_state = npc.action_state.none
|
|
-- Keep state the same if there are no more actions in actions queue
|
|
return self.freeze
|
|
end
|
|
local action_obj = self.actions.queue[1]
|
|
if action_obj.action == nil then
|
|
return
|
|
end
|
|
-- If the entry is a task, then push all this new operations in
|
|
-- stack fashion
|
|
if action_obj.is_task == true then
|
|
npc.log("DEBUG", "Executing task for NPC '"..dump(self.npc_name).."': "..dump(action_obj))
|
|
-- Backup current queue
|
|
local backup_queue = self.actions.queue
|
|
-- Remove this "task" action from queue
|
|
table.remove(self.actions.queue, 1)
|
|
-- Clear queue
|
|
self.actions.queue = {}
|
|
-- Now, execute the task with its arguments
|
|
result = npc.actions.execute(self, action_obj.action, action_obj.args)
|
|
--result = action_obj.action(self, action_obj.args)
|
|
-- After all new actions has been added by task, add the previously
|
|
-- queued actions back
|
|
for i = 1, #backup_queue do
|
|
table.insert(self.actions.queue, backup_queue[i])
|
|
end
|
|
else
|
|
npc.log("DEBUG", "Executing action for NPC '"..dump(self.npc_name).."': "..dump(action_obj))
|
|
-- Store the action that is being executed
|
|
self.actions.state_before_lock.interrupted_action = action_obj
|
|
-- Store current position
|
|
self.actions.state_before_lock.pos = self.object:getpos()
|
|
-- Execute action as normal
|
|
result = npc.actions.execute(self, action_obj.action, action_obj.args)
|
|
--result = action_obj.action(self, action_obj.args)
|
|
-- Remove task
|
|
table.remove(self.actions.queue, 1)
|
|
-- Set state
|
|
self.actions.current_action_state = npc.action_state.executing
|
|
end
|
|
return result
|
|
end
|
|
|
|
function npc.lock_actions(self)
|
|
|
|
-- Avoid re-locking if already locked
|
|
if self.actions.action_timer_lock == true then
|
|
return
|
|
end
|
|
|
|
local pos = self.object:getpos()
|
|
|
|
if self.freeze == false then
|
|
-- Round current pos to avoid the NPC being stopped on positions
|
|
-- where later on can't walk to the correct positions
|
|
-- Choose which position is to be taken as start position
|
|
if self.actions.state_before_lock.pos ~= {} then
|
|
pos = vector.round(self.actions.state_before_lock.pos)
|
|
else
|
|
pos = vector.round(self.object:getpos())
|
|
end
|
|
pos.y = self.object:getpos().y
|
|
end
|
|
-- Stop NPC
|
|
npc.actions.execute(self, npc.actions.cmd.STAND, {pos=pos})
|
|
-- Avoid all timer execution
|
|
self.actions.action_timer_lock = true
|
|
-- Reset timer so that it has some time after interaction is done
|
|
self.actions.action_timer = 0
|
|
-- Check if there are is an action executing
|
|
if self.actions.current_action_state == npc.action_state.executing
|
|
and self.freeze == false then
|
|
-- Store the current action state
|
|
self.actions.state_before_lock.action_state = self.actions.current_action_state
|
|
-- Set current action state to interrupted
|
|
self.actions.current_action_state = npc.action_state.interrupted
|
|
end
|
|
-- Store the current freeze variable
|
|
self.actions.state_before_lock.freeze = self.freeze
|
|
-- Freeze mobs_redo API
|
|
self.freeze = false
|
|
|
|
npc.log("DEBUG", "Locking NPC "..dump(self.npc_id).." actions")
|
|
end
|
|
|
|
function npc.unlock_actions(self)
|
|
-- Allow timers to execute
|
|
self.actions.action_timer_lock = false
|
|
-- Restore the value of self.freeze
|
|
self.freeze = self.actions.state_before_lock.freeze
|
|
|
|
if table.getn(self.actions.queue) == 0 then
|
|
-- Allow mobs_redo API to execute since action queue is empty
|
|
self.freeze = true
|
|
end
|
|
|
|
npc.log("DEBUG", "Unlocked NPC "..dump(self.npc_id).." actions")
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------
|
|
-- Schedule functionality
|
|
---------------------------------------------------------------------------------------
|
|
-- Schedules allow the NPC to do different things depending on the time of the day.
|
|
-- The time of the day is in 24 hours and is consistent with the Minetest Game
|
|
-- /time command. Hours will be written as numbers: 1 for 1:00, 13 for 13:00 or 1:00 PM
|
|
-- The API is as following: a schedule can be created for a specific date or for a
|
|
-- day of the week. A date is a string in the format MM:DD
|
|
npc.schedule_types = {
|
|
["generic"] = "generic",
|
|
["date_based"] = "date_based"
|
|
}
|
|
|
|
npc.schedule_properties = {
|
|
put_item = "put_item",
|
|
put_multiple_items = "put_multiple_items",
|
|
take_item = "take_item",
|
|
trader_status = "trader_status",
|
|
can_receive_gifts = "can_receive_gifts"
|
|
}
|
|
|
|
local function get_time_in_hours()
|
|
return minetest.get_timeofday() * 24
|
|
end
|
|
|
|
-- Create a schedule on a NPC.
|
|
-- Schedule types:
|
|
-- - Generic: Returns nil if there are already
|
|
-- seven schedules, one for each day of the
|
|
-- week or if the schedule attempting to add
|
|
-- already exists. The date parameter is the
|
|
-- day of the week it represents as follows:
|
|
-- - 1: Monday
|
|
-- - 2: Tuesday
|
|
-- - 3: Wednesday
|
|
-- - 4: Thursday
|
|
-- - 5: Friday
|
|
-- - 6: Saturday
|
|
-- - 7: Sunday
|
|
-- - Date-based: The date parameter should be a
|
|
-- string of the format "MM:DD". If it already
|
|
-- exists, function retuns nil
|
|
function npc.create_schedule(self, schedule_type, date)
|
|
if schedule_type == npc.schedule_types.generic then
|
|
-- Check that there are no more than 7 schedules
|
|
if #self.schedules.generic == 7 then
|
|
-- Unable to add schedule
|
|
return nil
|
|
elseif #self.schedules.generic < 7 then
|
|
-- Check schedule doesn't exists already
|
|
if self.schedules.generic[date] == nil then
|
|
-- Add schedule
|
|
self.schedules.generic[date] = {}
|
|
else
|
|
-- Schedule already present
|
|
return nil
|
|
end
|
|
end
|
|
elseif schedule_type == npc.schedule_types.date then
|
|
-- Check schedule doesn't exists already
|
|
if self.schedules.date_based[date] == nil then
|
|
-- Add schedule
|
|
self.schedules.date_based[date] = {}
|
|
else
|
|
-- Schedule already present
|
|
return nil
|
|
end
|
|
end
|
|
end
|
|
|
|
function npc.delete_schedule(self, schedule_type, date)
|
|
-- Delete schedule by setting entry to nil
|
|
self.schedules[schedule_type][date] = nil
|
|
end
|
|
|
|
-- Schedule entries API
|
|
-- Allows to add, get, update and delete entries from each
|
|
-- schedule. Attempts to be as safe-fail as possible to avoid crashes.
|
|
|
|
-- Actions is an array of actions and tasks that the NPC
|
|
-- will perform at the scheduled time on the scheduled date
|
|
function npc.add_schedule_entry(self, schedule_type, date, time, check, actions)
|
|
-- Check that schedule for date exists
|
|
if self.schedules[schedule_type][date] ~= nil then
|
|
-- Add schedule entry
|
|
if check == nil then
|
|
self.schedules[schedule_type][date][time] = actions
|
|
else
|
|
self.schedules[schedule_type][date][time].check = check
|
|
end
|
|
else
|
|
-- No schedule found, need to be created for date
|
|
return nil
|
|
end
|
|
end
|
|
|
|
function npc.get_schedule_entry(self, schedule_type, date, time)
|
|
-- Check if schedule for date exists
|
|
if self.schedules[schedule_type][date] ~= nil then
|
|
-- Return schedule
|
|
return self.schedules[schedule_type][date][time]
|
|
else
|
|
-- Schedule for date not found
|
|
return nil
|
|
end
|
|
end
|
|
|
|
function npc.update_schedule_entry(self, schedule_type, date, time, check, actions)
|
|
-- Check schedule for date exists
|
|
if self.schedules[schedule_type][date] ~= nil then
|
|
-- Check that a schedule entry for that time exists
|
|
if self.schedules[schedule_type][date][time] ~= nil then
|
|
-- Set the new actions
|
|
if check == nil then
|
|
self.schedules[schedule_type][date][time] = actions
|
|
else
|
|
self.schedules[schedule_type][date][time].check = check
|
|
end
|
|
else
|
|
-- Schedule not found for specified time
|
|
return nil
|
|
end
|
|
else
|
|
-- Schedule not found for date
|
|
return nil
|
|
end
|
|
end
|
|
|
|
function npc.delete_schedule_entry(self, schedule_type, date, time)
|
|
-- Check schedule for date exists
|
|
if self.schedules[schedule_type][date] ~= nil then
|
|
-- Remove schedule entry by setting to nil
|
|
self.schedules[schedule_type][date][time] = nil
|
|
else
|
|
-- Schedule not found for date
|
|
return nil
|
|
end
|
|
end
|
|
|
|
function npc.schedule_change_property(self, property, args)
|
|
if property == npc.schedule_properties.trader_status then
|
|
-- Get status from args
|
|
local status = args.status
|
|
-- Set status to NPC
|
|
npc.set_trading_status(self, status)
|
|
elseif property == npc.schedule_properties.put_item then
|
|
local itemstring = args.itemstring
|
|
-- Add item
|
|
npc.add_item_to_inventory_itemstring(self, itemstring)
|
|
elseif property == npc.schedule_properties.put_multiple_items then
|
|
local itemlist = args.itemlist
|
|
for i = 1, #itemlist do
|
|
local itemlist_entry = itemlist[i]
|
|
local current_itemstring = itemlist[i].name
|
|
if itemlist_entry.random == true then
|
|
current_itemstring = current_itemstring
|
|
.." "..dump(math.random(itemlist_entry.min, itemlist_entry.max))
|
|
else
|
|
current_itemstring = current_itemstring.." "..tostring(itemlist_entry.count)
|
|
end
|
|
-- Add item to inventory
|
|
npc.add_item_to_inventory_itemstring(self, current_itemstring)
|
|
end
|
|
elseif property == npc.schedule_properties.take_item then
|
|
local itemstring = args.itemstring
|
|
-- Add item
|
|
npc.take_item_from_inventory_itemstring(self, itemstring)
|
|
elseif property == npc.schedule_properties.can_receive_gifts then
|
|
local value = args.can_receive_gifts
|
|
-- Set status
|
|
self.can_receive_gifts = value
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------
|
|
-- NPC Definition
|
|
---------------------------------------------------------------------------------------
|
|
mobs:register_mob("advanced_npc:npc", {
|
|
type = "npc",
|
|
passive = false,
|
|
damage = 3,
|
|
attack_type = "dogfight",
|
|
attacks_monsters = true,
|
|
-- Added group attack
|
|
group_attack = true,
|
|
--pathfinding = true,
|
|
pathfinding = 1,
|
|
hp_min = 10,
|
|
hp_max = 20,
|
|
armor = 100,
|
|
collisionbox = {-0.20,-1.0,-0.20, 0.20,0.8,0.20},
|
|
--collisionbox = {-0.35,-1.0,-0.35, 0.35,0.8,0.35},
|
|
visual = "mesh",
|
|
mesh = "character.b3d",
|
|
drawtype = "front",
|
|
textures = {
|
|
{"npc_male1.png"},
|
|
{"npc_male2.png"},
|
|
{"npc_male3.png"},
|
|
{"npc_male4.png"},
|
|
{"npc_male5.png"},
|
|
{"npc_male6.png"},
|
|
{"npc_female1.png"}, -- female by nuttmeg20
|
|
},
|
|
child_texture = {
|
|
{"npc_child_male1.png"},
|
|
{"npc_child_female1.png"},
|
|
},
|
|
makes_footstep_sound = true,
|
|
sounds = {},
|
|
-- Added walk chance
|
|
walk_chance = 30,
|
|
-- Added stepheight
|
|
stepheight = 0.6,
|
|
walk_velocity = 1,
|
|
run_velocity = 3,
|
|
jump = false,
|
|
drops = {
|
|
{name = "default:wood", chance = 1, min = 1, max = 3},
|
|
{name = "default:apple", chance = 2, min = 1, max = 2},
|
|
{name = "default:axe_stone", chance = 5, min = 1, max = 1},
|
|
},
|
|
water_damage = 0,
|
|
lava_damage = 2,
|
|
light_damage = 0,
|
|
--follow = {"farming:bread", "mobs:meat", "default:diamond"},
|
|
view_range = 15,
|
|
owner = "",
|
|
order = "follow",
|
|
--order = "stand",
|
|
fear_height = 3,
|
|
animation = {
|
|
speed_normal = 30,
|
|
speed_run = 30,
|
|
stand_start = 0,
|
|
stand_end = 79,
|
|
walk_start = 168,
|
|
walk_end = 187,
|
|
run_start = 168,
|
|
run_end = 187,
|
|
punch_start = 200,
|
|
punch_end = 219,
|
|
},
|
|
on_rightclick = function(self, clicker)
|
|
|
|
-- Rotate NPC toward its clicker
|
|
npc.dialogue.rotate_npc_to_player(self)
|
|
|
|
-- Get information from clicker
|
|
local item = clicker:get_wielded_item()
|
|
local name = clicker:get_player_name()
|
|
|
|
npc.log("DEBUG", "Right-clicked NPC: "..dump(self))
|
|
|
|
-- Receive gift or start chat. If player has no item in hand
|
|
-- then it is going to start chat directly
|
|
minetest.log("self.can_have_relationship: "..dump(self.can_have_relationship)..", self.can_receive_gifts: "..dump(self.can_receive_gifts)..", table: "..dump(item:to_table()))
|
|
if self.can_have_relationship
|
|
and self.can_receive_gifts
|
|
and item:to_table() ~= nil then
|
|
-- Get item name
|
|
local item = minetest.registered_items[item:get_name()]
|
|
local item_name = item.description
|
|
|
|
-- Show dialogue to confirm that player is giving item as gift
|
|
npc.dialogue.show_yes_no_dialogue(
|
|
self,
|
|
"Do you want to give "..item_name.." to "..self.npc_name.."?",
|
|
npc.dialogue.POSITIVE_GIFT_ANSWER_PREFIX..item_name,
|
|
function()
|
|
npc.relationships.receive_gift(self, clicker)
|
|
end,
|
|
npc.dialogue.NEGATIVE_ANSWER_LABEL,
|
|
function()
|
|
npc.start_dialogue(self, clicker, true)
|
|
end,
|
|
name
|
|
)
|
|
else
|
|
npc.start_dialogue(self, clicker, true)
|
|
end
|
|
|
|
end,
|
|
do_custom = function(self, dtime)
|
|
if self.initialized == nil then
|
|
-- Initialize NPC if spawned using the spawn egg built in from
|
|
-- mobs_redo. This functionality will be removed in the future in
|
|
-- favor of a better manual spawning method with customization
|
|
npc.log("WARNING", "Initializing NPC from entity step. This message should only be appearing if an NPC is being spawned from inventory with egg!")
|
|
npc.initialize(self, self.object:getpos(), true)
|
|
self.tamed = false
|
|
self.owner = nil
|
|
else
|
|
-- NPC is initialized, check other variables
|
|
-- Check child texture issues
|
|
if self.is_child then
|
|
-- Check texture
|
|
npc.texture_check.timer = npc.texture_check.timer + dtime
|
|
if npc.texture_check.timer > npc.texture_check.interval then
|
|
-- Reset timer
|
|
npc.texture_check.timer = 0
|
|
-- Set hornytimer to zero every 60 seconds so that children
|
|
-- don't grow automatically
|
|
self.hornytimer = 0
|
|
-- Set correct textures
|
|
self.texture = {self.selected_texture}
|
|
self.base_texture = {self.selected_texture}
|
|
self.object:set_properties(self)
|
|
npc.log("WARNING", "Corrected textures on NPC child "..dump(self.npc_name))
|
|
-- Set interval to large interval so this code isn't called frequently
|
|
npc.texture_check.interval = 60
|
|
end
|
|
end
|
|
|
|
-- Timer function for casual traders to reset their trade offers
|
|
self.trader_data.change_offers_timer = self.trader_data.change_offers_timer + dtime
|
|
-- Check if time has come to change offers
|
|
if self.trader_data.trader_status == npc.trade.CASUAL and
|
|
self.trader_data.change_offers_timer >= self.trader_data.change_offers_timer_interval then
|
|
-- Reset timer
|
|
self.trader_data.change_offers_timer = 0
|
|
-- Re-select casual trade offers
|
|
npc.trade.generate_trade_offers_by_status(self)
|
|
end
|
|
|
|
-- Timer function for gifts
|
|
for i = 1, #self.relationships do
|
|
local relationship = self.relationships[i]
|
|
-- Gift timer check
|
|
if relationship.gift_timer_value < relationship.gift_interval then
|
|
relationship.gift_timer_value = relationship.gift_timer_value + dtime
|
|
elseif relationship.talk_timer_value < relationship.gift_interval then
|
|
-- Relationship talk timer - only allows players to increase relationship
|
|
-- by talking on the same intervals as gifts
|
|
relationship.talk_timer_value = relationship.talk_timer_value + dtime
|
|
else
|
|
-- Relationship decrease timer
|
|
if relationship.relationship_decrease_timer_value
|
|
< relationship.relationship_decrease_interval then
|
|
relationship.relationship_decrease_timer_value =
|
|
relationship.relationship_decrease_timer_value + dtime
|
|
else
|
|
-- Check if married to decrease half
|
|
if relationship.phase == "phase6" then
|
|
-- Avoid going below the marriage phase limit
|
|
if (relationship.points - 0.5) >=
|
|
npc.relationships.RELATIONSHIP_PHASE["phase5"].limit then
|
|
relationship.points = relationship.points - 0.5
|
|
end
|
|
else
|
|
relationship.points = relationship.points - 1
|
|
end
|
|
relationship.relationship_decrease_timer_value = 0
|
|
--minetest.log(dump(self))
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Action queue timer
|
|
-- Check if actions and timers aren't locked
|
|
if self.actions.action_timer_lock == false then
|
|
-- Increment action timer
|
|
self.actions.action_timer = self.actions.action_timer + dtime
|
|
if self.actions.action_timer >= self.actions.action_interval then
|
|
-- Reset action timer
|
|
self.actions.action_timer = 0
|
|
-- Check if NPC is walking
|
|
if self.actions.walking.is_walking == true then
|
|
local pos = self.actions.walking.target_pos
|
|
self.object:moveto({x=pos.x, y=pos.y + 0.5, z=pos.z})
|
|
end
|
|
-- Execute action
|
|
self.freeze = npc.execute_action(self)
|
|
-- Check if there are still remaining actions in the queue
|
|
if self.freeze == nil and table.getn(self.actions.queue) > 0 then
|
|
self.freeze = false
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Schedule timer
|
|
-- Check if schedules are enabled
|
|
if self.schedules.enabled == true then
|
|
-- Get time of day
|
|
local time = get_time_in_hours()
|
|
-- Check if time is an hour
|
|
if time % 1 < 0.1 and self.schedules.lock == false then
|
|
-- Activate lock to avoid more than one entry to this code
|
|
self.schedules.lock = true
|
|
-- Get integer part of time
|
|
time = (time) - (time % 1)
|
|
-- Check if there is a schedule entry for this time
|
|
-- Note: Currently only one schedule is supported, for day 0
|
|
--minetest.log("Time: "..dump(time))
|
|
local schedule = self.schedules.generic[0]
|
|
if schedule ~= nil then
|
|
-- Check if schedule for this time exists
|
|
--minetest.log("Found default schedule")
|
|
if schedule[time] ~= nil then
|
|
-- Check if schedule has a check function
|
|
if schedule[time].check ~= nil then
|
|
-- Execute check function and then add corresponding action
|
|
-- to action queue. This is for jobs.
|
|
-- TODO: Need to implement
|
|
else
|
|
npc.log("DEBUG", "Adding actions to action queue")
|
|
-- Add to action queue all actions on schedule
|
|
for i = 1, #schedule[time] do
|
|
--minetest.log("schedule[time]: "..dump(schedule[time]))
|
|
-- Check chance
|
|
local execution_chance = math.random(1, 100)
|
|
if not schedule[time][i].chance or
|
|
(schedule[time][i].chance and execution_chance <= schedule[time][i].chance) then
|
|
-- Check if entry has dependency on other entry
|
|
local dependencies_met = nil
|
|
if schedule[time][i].depends then
|
|
dependencies_met = npc.utils.array_is_subset_of_array(
|
|
self.schedules.temp_executed_queue,
|
|
schedule[time][i].depends)
|
|
end
|
|
|
|
-- Check for dependencies being met
|
|
if dependencies_met == nil or dependencies_met == true then
|
|
-- Add tasks
|
|
if schedule[time][i].task ~= nil then
|
|
-- Add task
|
|
npc.add_task(self, schedule[time][i].task, schedule[time][i].args)
|
|
elseif schedule[time][i].action ~= nil then
|
|
-- Add action
|
|
npc.add_action(self, schedule[time][i].action, schedule[time][i].args)
|
|
elseif schedule[time][i].property ~= nil then
|
|
-- Change NPC property
|
|
npc.schedule_change_property(self, schedule[time][i].property, schedule[time][i].args)
|
|
end
|
|
-- Backward compatibility check
|
|
if self.schedules.temp_executed_queue then
|
|
-- Add into execution queue to meet dependency
|
|
table.insert(self.schedules.temp_executed_queue, i)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- Clear execution queue
|
|
self.schedules.temp_executed_queue = {}
|
|
npc.log("DEBUG", "New action queue: "..dump(self.actions))
|
|
end
|
|
end
|
|
end
|
|
else
|
|
-- Check if lock can be released
|
|
if time % 1 > 0.1 then
|
|
-- Release lock
|
|
self.schedules.lock = false
|
|
end
|
|
end
|
|
end
|
|
|
|
return self.freeze
|
|
end
|
|
end
|
|
})
|
|
|
|
-- Spawn
|
|
-- mobs:spawn({
|
|
-- name = "advanced_npc:npc",
|
|
-- nodes = {"advanced_npc:plotmarker_auto_spawner", "mg_villages:plotmarker"},
|
|
-- min_light = 3,
|
|
-- active_object_count = 1,
|
|
-- interval = 5,
|
|
-- chance = 1,
|
|
-- --max_height = 0,
|
|
-- on_spawn = npc.initialize
|
|
-- })
|
|
|
|
-------------------------------------------------------------------------
|
|
-- Item definitions
|
|
-------------------------------------------------------------------------
|
|
|
|
mobs:register_egg("advanced_npc:npc", S("NPC"), "default_brick.png", 1)
|
|
|
|
-- compatibility
|
|
mobs:alias_mob("mobs:npc", "advanced_npc:npc")
|
|
|
|
-- Marriage ring
|
|
minetest.register_craftitem("advanced_npc:marriage_ring", {
|
|
description = S("Marriage Ring"),
|
|
inventory_image = "marriage_ring.png",
|
|
})
|
|
|
|
-- Marriage ring craft recipe
|
|
minetest.register_craft({
|
|
output = "advanced_npc:marriage_ring",
|
|
recipe = { {"", "", ""},
|
|
{"", "default:diamond", ""},
|
|
{"", "default:gold_ingot", ""} },
|
|
})
|