Actions: Rewrite API to use executor function + constants of commands.

Re-write NPC add action/task functions, do_custom() to use new actions API.
Spawner: Find building entrances (WIP)
Places: Fix numerous bugs with add/get places functions.
Actions: Fix bugs with sittable task.

actions/actions.lua

@@ -35,6 +35,24 @@ npc.actions.const = {
 	}
 }
 
+npc.actions.cmd = {
+	SET_INTERVAL = 0,
+	FREEZE = 1,
+	ROTATE = 2,
+	WALK_STEP = 3,
+	STAND = 4,
+	SIT = 5,
+	LAY = 6,
+	PUT_ITEM = 7,
+	TAKE_ITEM = 8,
+	CHECK_ITEM = 9,
+	USE_OPENABLE = 10,
+	USE_FURNACE = 11,
+	USE_BED = 12,
+	USE_SITTABLE = 13,
+	WALK_TO_POS = 14
+}
+
 --npc.actions.one_nps_speed = 0.98
 --npc.actions.one_half_nps_speed = 1.40
 --npc.actions.two_nps_speed = 1.90'
@@ -42,6 +60,67 @@ npc.actions.one_nps_speed = 1
 npc.actions.one_half_nps_speed = 1.5
 npc.actions.two_nps_speed = 2
 
+-- Executor --
+--------------
+-- Function references aren't reliable in Minetest entities. Objects get serialized
+-- and deserialized, as well as loaded and unloaded frequently which causes many
+-- function references to be lost and then crashes occurs due to nil variables.
+-- Using constants to refer to each method of this API and a function that
+-- understands those constants and executes the proper function is the way to avoid
+-- this frequent crashes.
+function npc.actions.execute(self, command, args)
+	if command == npc.actions.cmd.SET_INTERVAL then
+		--
+		return npc.actions.set_interval(self, args)
+	elseif command == npc.actions.cmd.FREEZE then
+		--
+		return npc.actions.freeze(self, args)
+	elseif command == npc.actions.cmd.ROTATE then
+		--
+		return npc.actions.rotate(self, args)
+	elseif command == npc.actions.cmd.WALK_STEP then
+		--
+		return npc.actions.walk_step(self, args)
+	elseif command == npc.actions.cmd.STAND then
+		--
+		return npc.actions.stand(self, args)
+	elseif command == npc.actions.cmd.SIT then
+		--
+		return npc.actions.sit(self, args)
+	elseif command == npc.actions.cmd.LAY then
+		--
+		return npc.actions.lay(self, args)
+	elseif command == npc.actions.cmd.PUT_ITEM then
+		-- 
+		return npc.actions.put_item_on_external_inventory(self, args)
+	elseif command == npc.actions.cmd.TAKE_ITEM then
+		--
+		return npc.actions.take_item_from_external_inventory(self, args)
+	elseif command == npc.actions.cmd.CHECK_ITEM then
+		--
+		return npc.actions.check_external_inventory_contains_item(self, args)
+	elseif command == npc.actions.cmd.USE_OPENABLE then
+		--
+		return npc.actions.use_openable(self, args)
+	elseif command == npc.actions.cmd.USE_FURNACE then
+		--
+		return npc.actions.use_furnace(self, args)
+	elseif command == npc.actions.cmd.USE_BED then
+		--
+		return npc.actions.use_bed(self, args)
+	elseif command == npc.actions.cmd.USE_SITTABLE then
+		-- Call use sittable task
+		return npc.actions.use_sittable(self, args)
+	elseif command == npc.actions.cmd.WALK_TO_POS then
+		-- Call walk to position task
+		minetest.log("Self: "..dump(self)..", Command: "..dump(command)..", args: "..dump(args))
+		return npc.actions.walk_to_pos(self, args)
+	end
+end
+
+-- TODO: Thanks to executor function, all the functions for Actions and Tasks
+-- should be made into private API
+
 ---------------------------------------------------------------------------------------
 -- Actions
 ---------------------------------------------------------------------------------------
@@ -303,7 +382,7 @@ end
 -- This function is used to open or close openable nodes.
 -- Currently supported openable nodes are: any doors using the
 -- default doors API, and the cottages mod gates and doors. 
-function npc.actions.use_door(self, args)
+function npc.actions.use_openable(self, args)
 	local pos = args.pos
 	local action = args.action
 	local dir = args.dir
@@ -400,7 +479,7 @@ function npc.actions.use_furnace(self, args)
 				 item_name = npc.get_item_name(fuel_item.item_string),
 				 count = fuel_amount
 			}
-      npc.add_action(self, npc.actions.put_item_on_external_inventory, args)
+			npc.add_action(self, npc.actions.cmd.PUT_ITEM, args)
 			-- Put the item that we want to cook on the furnace
 			args = {
 				 player = nil, 
@@ -410,20 +489,20 @@ function npc.actions.use_furnace(self, args)
 				 count = npc.get_item_count(item),
 				 is_furnace = true
 			}
-      npc.add_action(self, npc.actions.put_item_on_external_inventory, args)
+			npc.add_action(self, npc.actions.cmd.PUT_ITEM, args)
 
 			-- Now, set NPC to wait until furnace is done.
 			minetest.log("Setting wait action for "..dump(total_cook_time))
-      npc.add_action(self, npc.actions.set_interval, {interval=total_cook_time, freeze=freeze})
+			npc.add_action(self, npc.actions.cmd.SET_INTERVAL, {interval=total_cook_time, freeze=freeze})
 
 			-- Reset timer
-      npc.add_action(self, npc.actions.set_interval, {interval=1, freeze=true})
+			npc.add_action(self, npc.actions.cmd.SET_INTERVAL, {interval=1, freeze=true})
 
 			-- If freeze is false, then we will have to find the way back to the furnace
 			-- once cooking is done.
 			if freeze == false then
 				minetest.log("Adding walk to position to wandering: "..dump(pos))
-        npc.add_task(self, npc.actions.walk_to_pos, {end_pos=pos, walkable={}})
+				npc.add_task(self, npc.actions.cmd.WALK_TO_POS, {end_pos=pos, walkable={}})
 			end
 
 			-- Take cooked items back
@@ -437,7 +516,7 @@ function npc.actions.use_furnace(self, args)
 				 is_furnace = false
 			}
 			minetest.log("Taking item back: "..minetest.pos_to_string(pos))
-      npc.add_action(self, npc.actions.take_item_from_external_inventory, args)
+			npc.add_action(self, npc.actions.cmd.TAKE_ITEM, args)
 
 			minetest.log("Inventory: "..dump(self.inventory))
 
@@ -450,7 +529,9 @@ end
 
 -- This function makes the NPC lay or stand up from a bed. The
 -- pos is the location of the bed, action can be lay or get up
-function npc.actions.use_bed(self, pos, action)
+function npc.actions.use_bed(self, args)
+	local pos = args.pos
+	local action = args.action
 	local node = minetest.get_node(pos)
 	minetest.log(dump(node))
 	local dir = minetest.facedir_to_dir(node.param2)
@@ -459,15 +540,15 @@ function npc.actions.use_bed(self, pos, action)
 		-- Get position
 		local bed_pos = npc.actions.nodes.beds[node.name].get_lay_pos(pos, dir)
 		-- Sit down on bed, rotate to correct direction
-    npc.add_action(self, npc.actions.sit, {pos=bed_pos, dir=(node.param2 + 2) % 4})
+		npc.add_action(self, npc.actions.cmd.SIT, {pos=bed_pos, dir=(node.param2 + 2) % 4})
 		-- Lay down 
-    npc.add_action(self, npc.actions.lay, {})
+		npc.add_action(self, npc.actions.cmd.LAY, {})
 	else
 		-- Calculate position to get up
 		local bed_pos_y = npc.actions.nodes.beds[node.name].get_lay_pos(pos, dir).y
 		local bed_pos = {x = pos.x, y = bed_pos_y, z = pos.z} 
 		-- Sit up
-    npc.add_action(self, npc.actions.sit, {pos=bed_pos})
+		npc.add_action(self, npc.actions.cmd.SIT, {pos=bed_pos})
 		-- Initialize direction: Default is front of bottom of bed
 		local dir = (node.param2 + 2) % 4
 		-- Find empty node around node
@@ -498,7 +579,7 @@ function npc.actions.use_bed(self, pos, action)
 			end
 		end
 		-- Stand out of bed
-    npc.add_action(self, npc.actions.stand, {pos=pos_out_of_bed, dir=dir})
+		npc.add_action(self, npc.actions.cmd.STAND, {pos=pos_out_of_bed, dir=dir})
 	end
 end
 
@@ -510,26 +591,29 @@ function npc.actions.use_sittable(self, args)
 	local node = minetest.get_node(pos)
 
 	if action == npc.actions.const.sittable.SIT then
-    -- minetest.log("On sittable: Node: "..dump(node))
-    -- minetest.log("On sittable: Sittable stuff: "..dump(npc.actions.nodes.sittable[node.name]))
-    -- minetest.log("On sittable: HAHA: "..dump(node))
 		-- Calculate position depending on bench
 		local sit_pos = npc.actions.nodes.sittable[node.name].get_sit_pos(pos, node.param2)
 		-- Sit down on bench/chair/stairs
-    npc.add_action(self, npc.actions.sit, {pos=sit_pos, dir=(node.param2 + 2) % 4})
+		npc.add_action(self, npc.actions.cmd.SIT, {pos=sit_pos, dir=(node.param2 + 2) % 4})
 	else
 		-- Find empty areas around chair
 		local dir = node.param2 + 2 % 4
+		-- Default it to the current position in case it can't find empty
+		-- position around sittable node. Weird
+		local pos_out_of_sittable = pos
 		local empty_nodes = npc.places.find_node_orthogonally(pos, {"air"}, 0)
-    if empty_nodes ~= nil then
+		if empty_nodes ~= nil and #empty_nodes > 0 then
+			minetest.log("Empty nodes: "..dump(empty_nodes))
+			minetest.log("Npc.actions.get_direction: "..dump(npc.actions.get_direction))
+			minetest.log("Pos: "..dump(pos))
 			-- Get direction to the empty node
 			dir = npc.actions.get_direction(pos, empty_nodes[1].pos)
-    end
+			-- Calculate position to get out of sittable node
-    -- Calculate position to get out of bed
+			pos_out_of_sittable =
-    local pos_out_of_sittable =
 			{x=empty_nodes[1].pos.x, y=empty_nodes[1].pos.y + 1, z=empty_nodes[1].pos.z}
+		end
 		-- Stand
-    npc.add_action(self, npc.actions.stand, {pos=pos_out_of_sittable, dir=dir})
+		npc.add_action(self, npc.actions.cmd.STAND, {pos=pos_out_of_sittable, dir=dir})
 	end
 end
 
@@ -587,7 +671,7 @@ function npc.actions.walk_to_pos(self, args)
 
 		-- Set the action timer interval to half second. This is to account for
 		-- the increased speed when walking.
-    npc.add_action(self, npc.actions.set_interval, {interval=0.5, freeze=true})
+		npc.add_action(self, npc.actions.cmd.SET_INTERVAL, {interval=0.5, freeze=true})
 
 		-- Set the initial last and target positions
 		self.actions.walking.target_pos = path[1].pos
@@ -599,7 +683,7 @@ function npc.actions.walk_to_pos(self, args)
 				-- Add direction to last node
 				local dir = npc.actions.get_direction(path[i].pos, end_pos)
 				-- Add stand animation at end
-        npc.add_action(self, npc.actions.stand, {dir = dir})
+				npc.add_action(self, npc.actions.cmd.STAND, {dir = dir})
 				break
 			end
 			-- Get direction to move from path[i] to path[i+1]
@@ -611,16 +695,16 @@ function npc.actions.walk_to_pos(self, args)
 				if npc.actions.get_openable_node_state(node, dir) == npc.actions.const.doors.state.CLOSED then
 					minetest.log("Opening action to open door")
 					-- Stop to open door, this avoids misplaced movements later on
-          npc.add_action(self, npc.actions.stand, {dir=dir})
+					npc.add_action(self, npc.actions.cmd.STAND, {dir=dir})
 					-- Open door
-          npc.add_action(self, npc.actions.use_door, {pos=path[i+1].pos, dir=dir, action=npc.actions.const.doors.action.OPEN})
+					npc.add_action(self, npc.actions.cmd.USE_OPENABLE, {pos=path[i+1].pos, dir=dir, action=npc.actions.const.doors.action.OPEN})
 
 					door_opened = true
 				end
 			end
 
 			-- Add walk action to action queue
-      npc.add_action(self, npc.actions.walk_step, {dir = dir, speed = speed, target_pos = path[i+1].pos})
+			npc.add_action(self, npc.actions.cmd.WALK_STEP, {dir = dir, speed = speed, target_pos = path[i+1].pos})
 
 			if door_opened then
 					-- Stop to close door, this avoids misplaced movements later on
@@ -635,9 +719,9 @@ function npc.actions.walk_to_pos(self, args)
 						x_adj = -0.1
 					end
 					local pos_on_close = {x=path[i+1].pos.x + x_adj, y=path[i+1].pos.y + 1, z=path[i+1].pos.z + z_adj}
-          npc.add_action(self, npc.actions.stand, {dir=(dir + 2)% 4, pos=pos_on_close})
+					npc.add_action(self, npc.actions.cmd.STAND, {dir=(dir + 2)% 4, pos=pos_on_close})
 					-- Close door
-          npc.add_action(self, npc.actions.use_door, {pos=path[i+1].pos, action=npc.actions.const.doors.action.CLOSE})
+					npc.add_action(self, npc.actions.cmd.USE_OPENABLE, {pos=path[i+1].pos, action=npc.actions.const.doors.action.CLOSE})
 
 					door_opened = false
 			end
@@ -646,7 +730,7 @@ function npc.actions.walk_to_pos(self, args)
 
 		-- Return the action interval to default interval of 1 second
 		-- By default, always freeze.
-    npc.add_action(self, npc.actions.set_interval, {interval=1, freeze=true})
+		npc.add_action(self, npc.actions.cmd.SET_INTERVAL, {interval=1, freeze=true})
 
 	else
 		minetest.log("Unable to find path.")

actions/places.lua

@@ -53,22 +53,23 @@ npc.places.nodes = {
 
 npc.places.PLACE_TYPE = {
   BED = {
-    "PRIMARY"
+    PRIMARY = "primary"
   },
   SITTABLE = {
-    "PRIMARY"
+    PRIMARY = "primary"
   },
   OPENABLE = {
-    "HOME_ENTRANCE_DOOR"
+    HOME_ENTRANCE_DOOR = "home_entrance_door"
   },
   OTHER = {
-    "HOME_INSIDE",
+    HOME_INSIDE = "home_inside",
-    "HOME_OUTSIDE"
+    HOME_OUTSIDE = "home_outside"
   }
 }
 
 function npc.places.add_public(self, place_name, place_type, pos)
-	self.places_map[place_name] = {type=place_type, pos=pos}
+  --minetest.log("Place name: "..dump(place_name)..", type: "..dump(place_type))
+	self.places_map[place_name] = {type=place_type, pos=pos, status="shared"}
 end
 
 -- Adds a specific node to the NPC places, and modifies the
@@ -92,7 +93,7 @@ function npc.places.get_by_type(self, place_type)
 	local result = {}
 	for place_name, place_entry in pairs(self.places_map) do
 		if place_entry.type == place_type then
-      table.insert(result, place_name)
+      table.insert(result, place_entry)
     end
 	end
   return result

npc.lua

@@ -329,13 +329,13 @@ function npc.initialize(entity, pos, is_lua_entity)
   npc.create_schedule(ent, npc.schedule_types.generic, 0)
   -- Add schedule entries
   local morning_actions = { 
-    [1] = {task = npc.actions.walk_to_pos, args = {end_pos=nodes[1], walkable={}} } ,
+    [1] = {task = npc.actions.cmd.WALK_TO_POS, args = {end_pos=nodes[1], walkable={}} } ,
-    [2] = {task = npc.actions.use_sittable, args = {pos=nodes[1], action=npc.actions.const.sittable.SIT} }, 
+    [2] = {task = npc.actions.cmd.USE_SITTABLE, args = {pos=nodes[1], action=npc.actions.const.sittable.SIT} }, 
-    [3] = {action = npc.actions.freeze, args = {freeze = true}}
+    [3] = {action = npc.actions.cmd.FREEZE, args = {freeze = true}}
   }
   npc.add_schedule_entry(ent, npc.schedule_types.generic, 0, 7, nil, morning_actions)
   --local afternoon_actions = { [1] = {action = npc.actions.stand, args = {}} }
-  local afternoon_actions = {[1] = {task = npc.actions.use_sittable, args = {pos=nodes[1], action=npc.actions.const.sittable.GET_UP} } }
+  local afternoon_actions = {[1] = {task = npc.actions.cmd.USE_SITTABLE, args = {pos=nodes[1], action=npc.actions.const.sittable.GET_UP} } }
   npc.add_schedule_entry(ent, npc.schedule_types.generic, 0, 9, nil, afternoon_actions)
   -- local night_actions = {action: npc.action, args: {}}
   -- npc.add_schedule_entry(self, npc.schedule_type.generic, 0, 19, check, actions)
@@ -530,7 +530,7 @@ end
 function npc.execute_action(self)
   -- Check if an action was interrupted
   if self.actions.current_action_state == npc.action_state.interrupted then
-    minetest.log("Inserting interrupted action: ")
+    minetest.log("[advanced_npc] DEBUG Re-inserting interrupted action for NPC: '"..dump(self.nametag).."': "..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
@@ -552,7 +552,7 @@ function npc.execute_action(self)
   -- If the entry is a task, then push all this new operations in
   -- stack fashion
   if action_obj.is_task == true then
-    minetest.log("Executing task: "..dump(action_obj))
+    minetest.log("[advanced_npc] DEBUG Executing task for NPC '"..dump(self.nametag).."': "..dump(action_obj))
     -- Backup current queue
     local backup_queue = self.actions.queue
     -- Remove this "task" action from queue
@@ -560,20 +560,22 @@ function npc.execute_action(self)
     -- Clear queue
     self.actions.queue = {}
     -- Now, execute the task with its arguments
-    action_obj.action(self, action_obj.args)
+    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
-    minetest.log("Executing action")
+    minetest.log("[advanced_npc] DEBUG Executing action for NPC '"..dump(self.nametag).."': "..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 = action_obj.action(self, action_obj.args)
+    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
@@ -603,7 +605,7 @@ function npc.lock_actions(self)
     pos.y = self.object:getpos().y
   end
   -- Stop NPC
-  npc.actions.stand(self, {pos=pos})
+  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

random_data.lua

@@ -75,7 +75,7 @@ npc.data.DIALOGUES.female["phase1"] = {
                   item_name=npc.trade.prices.currency.tier3.string, 
                   count=3
                 }
-                npc.actions.take_item_from_external_inventory(self, {
+                npc.actions.execute(self, npc.actions.cmd.TAKE_ITEM, {
                   player=player:get_player_name(), 
                   pos=nil, 
                   inv_list="main", 

spawner.lua

@@ -129,6 +129,36 @@ end
 --     - Else, just let the NPC know one of the benches, but not own them
 --   - Let the NPC know all doors to the house. Identify the front one as the entrance
 function spawner.assign_places(self, pos)
+  local meta = minetest.get_meta(pos)
+  local doors = minetest.deserialize(meta:get_string("node_data")).openable_type
+  minetest.log("Found "..dump(#doors).." openable nodes")
+
+  local entrance = npc.places.find_entrance_from_openable_nodes(doors, pos)
+  if entrance then
+    minetest.log("Found building entrance at: "..minetest.pos_to_string(entrance.node_pos))
+  else
+    minetest.log("Unable to find building entrance!")
+  end
+
+  -- Assign entrance door and related locations
+  if entrance ~= nil and entrance.node_pos ~= nil then
+    --minetest.log("Self: "..dump(self))
+    --minetest.log("Places map: "..dump(self.places_map))
+    npc.places.add_public(self, npc.places.PLACE_TYPE.OPENABLE.HOME_ENTRANCE_DOOR, npc.places.PLACE_TYPE.OPENABLE.HOME_ENTRANCE_DOOR, entrance.node_pos)
+    -- Find the position inside and outside the door
+    local entrance_inside = npc.places.find_node_behind_door(entrance.node_pos)
+    local entrance_outside = npc.places.find_node_in_front_of_door(entrance.node_pos)
+    -- Assign these places to NPC
+    npc.places.add_public(self, npc.places.PLACE_TYPE.OTHER.HOME_INSIDE, npc.places.PLACE_TYPE.OTHER.HOME_INSIDE, entrance_inside)
+    npc.places.add_public(self, npc.places.PLACE_TYPE.OTHER.HOME_OUTSIDE, npc.places.PLACE_TYPE.OTHER.HOME_OUTSIDE, entrance_outside)
+    -- Make NPC go into their house
+    --minetest.log("Place: "..dump(npc.places.get_by_type(self, npc.places.PLACE_TYPE.OTHER.HOME_INSIDE)))
+    npc.add_task(self, npc.actions.cmd.WALK_TO_POS, {end_pos=npc.places.get_by_type(self, npc.places.PLACE_TYPE.OTHER.HOME_INSIDE)[1].pos, walkable={}})  
+  end
+
+  local plot_info = minetest.deserialize(meta:get_string("plot_info"))
+  minetest.log("Plot info:"..dump(plot_info))
+
 
 end
 
@@ -151,7 +181,7 @@ function npc.spawner.spawn_npc(pos)
       ent:get_luaentity().initialized = false
       npc.initialize(ent, pos)
       -- Assign nodes
-      spawner.assign_places(ent, pos)
+      spawner.assign_places(ent:get_luaentity(), pos)
       -- Increase NPC spawned count
       spawned_npc_count = spawned_npc_count + 1
       -- Store count into node
@@ -351,19 +381,6 @@ if minetest.get_modpath("mg_villages") ~= nil then
     on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
       -- Get all openable-type nodes for this building
       -- NOTE: This is temporary code for testing...
-      local meta = minetest.get_meta(pos)
-      local doors = minetest.deserialize(meta:get_string("node_data")).openable_type
-      minetest.log("Found "..dump(#doors).." openable nodes")
-    
-      local entrance = npc.places.find_entrance_from_openable_nodes(doors, pos)
-      if entrance then
-        minetest.log("Found building entrance at: "..minetest.pos_to_string(entrance.node_pos))
-      else
-        minetest.log("Unable to find building entrance!")
-      end
-
-      local plot_info = minetest.deserialize(meta:get_string("plot_info"))
-      minetest.log("Plot info:"..dump(plot_info))
 
       return mg_villages.plotmarker_formspec( pos, nil, {}, clicker )
     end,