From 9b1ceebf0d3db46d8f3f40f478e9af121cf2decd Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Wed, 7 Dec 2022 23:38:44 +0000
Subject: [PATCH 01/13] Villagers will now pathfind to town bell that isn't on
 the ground

---
 mods/ENTITIES/mcl_mobs/pathfinding.lua |  7 ++++---
 mods/ENTITIES/mobs_mc/villager.lua     | 18 ++++++++++++++++--
 2 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/mods/ENTITIES/mcl_mobs/pathfinding.lua b/mods/ENTITIES/mcl_mobs/pathfinding.lua
index 6cb37434f..04138bed0 100644
--- a/mods/ENTITIES/mcl_mobs/pathfinding.lua
+++ b/mods/ENTITIES/mcl_mobs/pathfinding.lua
@@ -35,19 +35,20 @@ function append_paths (wp1, wp2)
 end
 
 local function output_enriched (wp_out)
-	mcl_log("Output enriched path")
+	--mcl_log("Output enriched path")
 	local i = 0
 	for _,outy in pairs (wp_out) do
 		i = i + 1
-		mcl_log("Pos ".. i ..":" .. minetest.pos_to_string(outy["pos"]))
+		--mcl_log("Pos ".. i ..":" .. minetest.pos_to_string(outy["pos"]))
 
 		local action =  outy["action"]
 		if action then
+			mcl_log("Pos ".. i ..":" .. minetest.pos_to_string(outy["pos"]))
 			mcl_log("type: " .. action["type"])
 			mcl_log("action: " .. action["action"])
 			mcl_log("target: " .. minetest.pos_to_string(action["target"]))
 		end
-		mcl_log("failed attempts: " .. outy["failed_attempts"])
+		--mcl_log("failed attempts: " .. outy["failed_attempts"])
 	end
 end
 
diff --git a/mods/ENTITIES/mobs_mc/villager.lua b/mods/ENTITIES/mobs_mc/villager.lua
index 9215416b8..b1f73247c 100644
--- a/mods/ENTITIES/mobs_mc/villager.lua
+++ b/mods/ENTITIES/mobs_mc/villager.lua
@@ -1190,6 +1190,19 @@ local function do_work (self)
 	end
 end
 
+local below_vec = vector.new(0, -1, 0)
+
+local function get_ground_below_floating_object (float_pos)
+	local pos = float_pos
+	repeat
+		mcl_log("Current pos: " .. minetest.pos_to_string(pos))
+		pos = vector.add(pos, below_vec)
+		local node = minetest.get_node(pos)
+		mcl_log("First non air materials: ".. tostring(node.name))
+	until node.name ~= "air"
+	return pos
+end
+
 local function go_to_town_bell(self)
 	if self.order == GATHERING then
 		mcl_log("Already gathering")
@@ -1208,8 +1221,9 @@ local function go_to_town_bell(self)
 	--Ideally should check for closest available. It'll make pathing easier.
 	for _,n in pairs(nn) do
 		mcl_log("Found bell")
-
-		local gp = self:gopath(n,function(self)
+		local target_point = get_ground_below_floating_object(n)
+		
+		local gp = self:gopath(target_point,function(self)
 			if self then
 				self.order = GATHERING
 				mcl_log("Callback has a self")

From 5c0a763b836798530da5a624fe0f99f9d466fe83 Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Fri, 9 Dec 2022 19:07:45 +0000
Subject: [PATCH 02/13] Optimisation - Only check for town bell if ready to
 path

---
 mods/ENTITIES/mcl_mobs/pathfinding.lua | 31 ++++++++++++++++++++------
 mods/ENTITIES/mobs_mc/villager.lua     | 10 +++++++--
 2 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/mods/ENTITIES/mcl_mobs/pathfinding.lua b/mods/ENTITIES/mcl_mobs/pathfinding.lua
index 04138bed0..5f70760da 100644
--- a/mods/ENTITIES/mcl_mobs/pathfinding.lua
+++ b/mods/ENTITIES/mcl_mobs/pathfinding.lua
@@ -120,22 +120,27 @@ local function calculate_path_through_door (p, t, target)
 	local pos_closest_to_door = nil
 	local other_side_of_door = nil
 
-	--Path to door first
+	--Check direct route
 	local wp = minetest.find_path(p,t,150,1,4)
+
+	--Path to door first
 	if not wp then
 		mcl_log("No direct path. Path through door")
 
 		-- This could improve. There could be multiple doors. Check you can path from door to target first.
+
+		-- target could be pos
 		local cur_door_pos = minetest.find_node_near(target,16,{"group:door"})
 		if cur_door_pos then
 			mcl_log("Found a door near: " .. minetest.pos_to_string(cur_door_pos))
 			for _,v in pairs(plane_adjacents) do
 				pos_closest_to_door = vector.add(cur_door_pos,v)
-
 				local n = minetest.get_node(pos_closest_to_door)
 				if n.name == "air" then
+
 					wp = minetest.find_path(p,pos_closest_to_door,150,1,4)
 					if wp then
+
 						mcl_log("Found a path to next to door".. minetest.pos_to_string(pos_closest_to_door))
 						other_side_of_door = vector.add(cur_door_pos,-v)
 						mcl_log("Opposite is: ".. minetest.pos_to_string(other_side_of_door))
@@ -154,7 +159,7 @@ local function calculate_path_through_door (p, t, target)
 						mcl_log("This block next to door doesn't work.")
 					end
 				else
-					mcl_log("Block is not air, it is: ".. n.name)
+					--mcl_log("Block is not air, it is: ".. n.name)
 				end
 
 			end
@@ -165,21 +170,33 @@ local function calculate_path_through_door (p, t, target)
 		mcl_log("We have a direct route")
 	end
 
+	-- If not, get door near pos
+	--path from pos to door, path from otherside to target
+
 	if wp and not enriched_path then
 		enriched_path = generate_enriched_path(wp)
 	end
 	return enriched_path
 end
 
-local gopath_last = os.time()
+--local gopath_last = os.time()
+
+function mob_class:ready_to_path()
+	mcl_log("Check ready to path")
+	if self._pf_last_failed and (os.time() - self._pf_last_failed) < 30 then
+		return false
+	else
+		mcl_log("We are ready to pathfind, no previous fail or we are past threshold")
+		return true
+	end
+end
+
 function mob_class:gopath(target,callback_arrived)
 	if self.state == PATHFINDING then mcl_log("Already pathfinding, don't set another until done.") return end
 
-	if self._pf_last_failed and (os.time() - self._pf_last_failed) < 30 then
+	if not self:ready_to_path() then
 		mcl_log("We are not ready to path as last fail is less than threshold: " .. (os.time() - self._pf_last_failed))
 		return
-	else
-		mcl_log("We are ready to pathfind, no previous fail or we are past threshold")
 	end
 
 	--if os.time() - gopath_last < 5 then
diff --git a/mods/ENTITIES/mobs_mc/villager.lua b/mods/ENTITIES/mobs_mc/villager.lua
index b1f73247c..c9a8ab602 100644
--- a/mods/ENTITIES/mobs_mc/villager.lua
+++ b/mods/ENTITIES/mobs_mc/villager.lua
@@ -1205,11 +1205,17 @@ end
 
 local function go_to_town_bell(self)
 	if self.order == GATHERING then
-		mcl_log("Already gathering")
+		--mcl_log("Already gathering")
 		return
 	else
 		mcl_log("Current order" .. self.order)
 	end
+
+	if not self:ready_to_path() then
+		mcl_log("Negative response to go_path. Do not bother")
+		return
+	end
+
 	mcl_log("Go to town bell")
 
 	local looking_for_type={}
@@ -1222,7 +1228,7 @@ local function go_to_town_bell(self)
 	for _,n in pairs(nn) do
 		mcl_log("Found bell")
 		local target_point = get_ground_below_floating_object(n)
-		
+
 		local gp = self:gopath(target_point,function(self)
 			if self then
 				self.order = GATHERING

From 29cd73cb84f641267b52ddcff54fa65a64dfe6c1 Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Fri, 30 Dec 2022 04:15:59 +0000
Subject: [PATCH 03/13] Pathfinding through door should also check door closest
 to position so villager can leave current house

---
 mods/ENTITIES/mcl_mobs/pathfinding.lua | 154 +++++++++++++------------
 1 file changed, 81 insertions(+), 73 deletions(-)

diff --git a/mods/ENTITIES/mcl_mobs/pathfinding.lua b/mods/ENTITIES/mcl_mobs/pathfinding.lua
index 5f70760da..f89f4a323 100644
--- a/mods/ENTITIES/mcl_mobs/pathfinding.lua
+++ b/mods/ENTITIES/mcl_mobs/pathfinding.lua
@@ -35,11 +35,11 @@ function append_paths (wp1, wp2)
 end
 
 local function output_enriched (wp_out)
-	--mcl_log("Output enriched path")
+	mcl_log("Output enriched path")
 	local i = 0
 	for _,outy in pairs (wp_out) do
 		i = i + 1
-		--mcl_log("Pos ".. i ..":" .. minetest.pos_to_string(outy["pos"]))
+		mcl_log("Pos ".. i ..":" .. minetest.pos_to_string(outy["pos"]))
 
 		local action =  outy["action"]
 		if action then
@@ -109,76 +109,6 @@ local plane_adjacents = {
 	vector.new(0,0,-1),
 }
 
--- This function is used to see if we can path. We could use to check a route, rather than making people move.
-local function calculate_path_through_door (p, t, target)
-	-- target is the same as t, just 1 square difference. Maybe we don't need target
-	mcl_log("Plot route from mob: " .. minetest.pos_to_string(p) .. ", to target: " .. minetest.pos_to_string(t))
-
-	local enriched_path = nil
-
-	local cur_door_pos = nil
-	local pos_closest_to_door = nil
-	local other_side_of_door = nil
-
-	--Check direct route
-	local wp = minetest.find_path(p,t,150,1,4)
-
-	--Path to door first
-	if not wp then
-		mcl_log("No direct path. Path through door")
-
-		-- This could improve. There could be multiple doors. Check you can path from door to target first.
-
-		-- target could be pos
-		local cur_door_pos = minetest.find_node_near(target,16,{"group:door"})
-		if cur_door_pos then
-			mcl_log("Found a door near: " .. minetest.pos_to_string(cur_door_pos))
-			for _,v in pairs(plane_adjacents) do
-				pos_closest_to_door = vector.add(cur_door_pos,v)
-				local n = minetest.get_node(pos_closest_to_door)
-				if n.name == "air" then
-
-					wp = minetest.find_path(p,pos_closest_to_door,150,1,4)
-					if wp then
-
-						mcl_log("Found a path to next to door".. minetest.pos_to_string(pos_closest_to_door))
-						other_side_of_door = vector.add(cur_door_pos,-v)
-						mcl_log("Opposite is: ".. minetest.pos_to_string(other_side_of_door))
-
-						local wp_otherside_door_to_target = minetest.find_path(other_side_of_door,t,150,1,4)
-						if wp_otherside_door_to_target and #wp_otherside_door_to_target > 0 then
-							table.insert(wp, cur_door_pos)
-							append_paths (wp, wp_otherside_door_to_target)
-							enriched_path = generate_enriched_path(wp, pos_closest_to_door, other_side_of_door, cur_door_pos)
-							mcl_log("We have a path from outside door to target")
-						else
-							mcl_log("We cannot path from outside door to target")
-						end
-						break
-					else
-						mcl_log("This block next to door doesn't work.")
-					end
-				else
-					--mcl_log("Block is not air, it is: ".. n.name)
-				end
-
-			end
-		else
-			mcl_log("No door found")
-		end
-	else
-		mcl_log("We have a direct route")
-	end
-
-	-- If not, get door near pos
-	--path from pos to door, path from otherside to target
-
-	if wp and not enriched_path then
-		enriched_path = generate_enriched_path(wp)
-	end
-	return enriched_path
-end
-
 --local gopath_last = os.time()
 
 function mob_class:ready_to_path()
@@ -191,6 +121,63 @@ function mob_class:ready_to_path()
 	end
 end
 
+-- This function is used to see if we can path. We could use to check a route, rather than making people move.
+local function calculate_path_through_door (p, t, cur_door_pos)
+	-- target is the same as t, just 1 square difference. Maybe we don't need target
+	mcl_log("Plot route from mob: " .. minetest.pos_to_string(p) .. ", to target: " .. minetest.pos_to_string(t))
+
+	local enriched_path = nil
+
+	--local cur_door_pos = nil
+	local pos_closest_to_door = nil
+	local other_side_of_door = nil
+
+	local wp
+
+	if cur_door_pos then
+		mcl_log("Found a door near: " .. minetest.pos_to_string(cur_door_pos))
+		for _,v in pairs(plane_adjacents) do
+			pos_closest_to_door = vector.add(cur_door_pos,v)
+			local n = minetest.get_node(pos_closest_to_door)
+
+			if n.name == "air" then
+				mcl_log("We have air space next to door at: " .. minetest.pos_to_string(pos_closest_to_door))
+
+				wp = minetest.find_path(p,pos_closest_to_door,150,1,4)
+
+				if wp then
+					mcl_log("Found a path to next to door".. minetest.pos_to_string(pos_closest_to_door))
+					other_side_of_door = vector.add(cur_door_pos,-v)
+					mcl_log("Opposite is: ".. minetest.pos_to_string(other_side_of_door))
+
+					local wp_otherside_door_to_target = minetest.find_path(other_side_of_door,t,150,1,4)
+					if wp_otherside_door_to_target and #wp_otherside_door_to_target > 0 then
+						table.insert(wp, cur_door_pos)
+						append_paths (wp, wp_otherside_door_to_target)
+						enriched_path = generate_enriched_path(wp, pos_closest_to_door, other_side_of_door, cur_door_pos)
+						mcl_log("We have a path from outside door to target")
+					else
+						mcl_log("We cannot path from outside door to target")
+					end
+					break
+				else
+					mcl_log("This block next to door doesn't work.")
+				end
+			end
+		end
+	else
+		mcl_log("No door found")
+	end
+
+	if wp and not enriched_path then
+		mcl_log("Wp but not enriched")
+		enriched_path = generate_enriched_path(wp)
+	end
+	return enriched_path
+end
+
+
+
 function mob_class:gopath(target,callback_arrived)
 	if self.state == PATHFINDING then mcl_log("Already pathfinding, don't set another until done.") return end
 
@@ -210,7 +197,28 @@ function mob_class:gopath(target,callback_arrived)
 	local p = self.object:get_pos()
 	local t = vector.offset(target,0,1,0)
 
-	local wp = calculate_path_through_door(p, t, target)
+	--Check direct route
+	local wp = minetest.find_path(p,t,150,1,4)
+
+	if not wp then
+		mcl_log("No direct path. Path through door")
+		-- target could be pos
+		local cur_door_pos = minetest.find_node_near(target, 16, {"group:door"})
+		wp = calculate_path_through_door(p, t, cur_door_pos)
+
+		if not wp then
+			mcl_log("No path though door closest to target. Try door closest to origin.")
+			cur_door_pos = minetest.find_node_near(p, 16, {"group:door"})
+			wp = calculate_path_through_door(p, t, cur_door_pos)
+		end
+	else
+		wp = generate_enriched_path(wp)
+		mcl_log("We have a direct route")
+	end
+
+	--path from pos to door, path from otherside to target
+
+
 	if not wp then
 		mcl_log("Could not calculate path")
 		self._pf_last_failed = os.time()

From e3307d647b720cfea3c6d4f6833bb2f075a07ae7 Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Fri, 30 Dec 2022 14:17:24 +0000
Subject: [PATCH 04/13] Fix pathing to bell that is sat on the ground

---
 mods/ENTITIES/mobs_mc/villager.lua | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/mods/ENTITIES/mobs_mc/villager.lua b/mods/ENTITIES/mobs_mc/villager.lua
index c9a8ab602..dcc16e16f 100644
--- a/mods/ENTITIES/mobs_mc/villager.lua
+++ b/mods/ENTITIES/mobs_mc/villager.lua
@@ -641,7 +641,7 @@ function get_activity(tod)
 	else
 		activity = "chill"
 	end
-	mcl_log("Time is " .. tod ..". Activity is: ".. activity)
+	--mcl_log("Time is " .. tod ..". Activity is: ".. activity)
 	return activity
 
 end
@@ -1200,6 +1200,16 @@ local function get_ground_below_floating_object (float_pos)
 		local node = minetest.get_node(pos)
 		mcl_log("First non air materials: ".. tostring(node.name))
 	until node.name ~= "air"
+
+	-- If pos is 1 below float_pos, then just return float_pos as there is no air below it
+	if pos.y == float_pos.y -1 then
+		--mcl_log("pos is only 1 lower than float pos so no air below")
+		return float_pos
+	else
+		--mcl_log("pos is more than 1 lower than float pos so air is below")
+		return pos
+	end
+
 	return pos
 end
 

From 87f04bdd9f5eb9de2c2162a32a86bf3540ad63ad Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Fri, 30 Dec 2022 15:10:55 +0000
Subject: [PATCH 05/13] Prevent attempting to path through 2 doors until code
 supports it. Clean up also.

---
 mods/ENTITIES/mcl_mobs/pathfinding.lua | 46 +++++++++++++-------------
 mods/ENTITIES/mobs_mc/villager.lua     |  2 +-
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/mods/ENTITIES/mcl_mobs/pathfinding.lua b/mods/ENTITIES/mcl_mobs/pathfinding.lua
index f89f4a323..db58ff777 100644
--- a/mods/ENTITIES/mcl_mobs/pathfinding.lua
+++ b/mods/ENTITIES/mcl_mobs/pathfinding.lua
@@ -3,7 +3,6 @@ local mob_class = mcl_mobs.mob_class
 
 local LOGGING_ON = minetest.settings:get_bool("mcl_logging_mobs_villager",false)
 local PATHFINDING = "gowp"
-local enable_pathfinding = true
 
 local LOG_MODULE = "[Mobs]"
 local function mcl_log (message)
@@ -64,26 +63,27 @@ local function generate_enriched_path(wp_in, door_open_pos, door_close_pos, cur_
 		local cur_pos_to_add = vector.add(cur_pos, one_down)
 		if door_open_pos and vector.equals (cur_pos, door_open_pos) then
 			mcl_log ("Door open match")
-			--action = {type = "door", action = "open"}
-			action = {}
-			action["type"] = "door"
-			action["action"] = "open"
+			action = {type = "door", action = "open"}
+			--action = {}
+			--action["type"] = "door"
+			--action["action"] = "open"
 			action["target"] = cur_door_pos
 			cur_pos_to_add = vector.add(cur_pos, one_down)
 		elseif door_close_pos and vector.equals(cur_pos, door_close_pos) then
 			mcl_log ("Door close match")
-			--action = {type = "door", action = "closed"}
-			action = {}
-			action["type"] = "door"
-			action["action"] = "close"
+			action = {type = "door", action = "close"}
+			--action = {}
+			--action["type"] = "door"
+			--action["action"] = "close"
 			action["target"] = cur_door_pos
 			cur_pos_to_add = vector.add(cur_pos, one_down)
 		elseif cur_door_pos and vector.equals(cur_pos, cur_door_pos) then
 			mcl_log("Current door pos")
 			cur_pos_to_add = vector.add(cur_pos, one_down)
-			action = {}
-			action["type"] = "door"
-			action["action"] = "open"
+			action = {type = "door", action = "open"}
+			--action = {}
+			--action["type"] = "door"
+			--action["action"] = "open"
 			action["target"] = cur_door_pos
 		else
 			cur_pos_to_add = cur_pos
@@ -132,7 +132,7 @@ local function calculate_path_through_door (p, t, cur_door_pos)
 	local pos_closest_to_door = nil
 	local other_side_of_door = nil
 
-	local wp
+	local wp, prospective_wp
 
 	if cur_door_pos then
 		mcl_log("Found a door near: " .. minetest.pos_to_string(cur_door_pos))
@@ -143,18 +143,19 @@ local function calculate_path_through_door (p, t, cur_door_pos)
 			if n.name == "air" then
 				mcl_log("We have air space next to door at: " .. minetest.pos_to_string(pos_closest_to_door))
 
-				wp = minetest.find_path(p,pos_closest_to_door,150,1,4)
+				prospective_wp = minetest.find_path(p,pos_closest_to_door,150,1,4)
 
-				if wp then
+				if prospective_wp then
 					mcl_log("Found a path to next to door".. minetest.pos_to_string(pos_closest_to_door))
 					other_side_of_door = vector.add(cur_door_pos,-v)
 					mcl_log("Opposite is: ".. minetest.pos_to_string(other_side_of_door))
 
 					local wp_otherside_door_to_target = minetest.find_path(other_side_of_door,t,150,1,4)
 					if wp_otherside_door_to_target and #wp_otherside_door_to_target > 0 then
-						table.insert(wp, cur_door_pos)
-						append_paths (wp, wp_otherside_door_to_target)
-						enriched_path = generate_enriched_path(wp, pos_closest_to_door, other_side_of_door, cur_door_pos)
+						table.insert(prospective_wp, cur_door_pos)
+						append_paths (prospective_wp, wp_otherside_door_to_target)
+						enriched_path = generate_enriched_path(prospective_wp, pos_closest_to_door, other_side_of_door, cur_door_pos)
+						wp = prospective_wp
 						mcl_log("We have a path from outside door to target")
 					else
 						mcl_log("We cannot path from outside door to target")
@@ -202,7 +203,6 @@ function mob_class:gopath(target,callback_arrived)
 
 	if not wp then
 		mcl_log("No direct path. Path through door")
-		-- target could be pos
 		local cur_door_pos = minetest.find_node_near(target, 16, {"group:door"})
 		wp = calculate_path_through_door(p, t, cur_door_pos)
 
@@ -218,15 +218,14 @@ function mob_class:gopath(target,callback_arrived)
 
 	--path from pos to door, path from otherside to target
 
-
 	if not wp then
 		mcl_log("Could not calculate path")
 		self._pf_last_failed = os.time()
-		-- Cover for a flaw in pathfind where it chooses the wrong door and gets stuck. Take a break, allow others.
+		-- If cannot path, don't immediately try again
 	end
-	--output_table(wp)
 
 	if wp and #wp > 0 then
+		--output_table(wp)
 		self._target = t
 		self.callback_arrived = callback_arrived
 		local current_location = table.remove(wp,1)
@@ -318,7 +317,7 @@ function mob_class:check_gowp(dtime)
 	-- arrived at location, finish gowp
 	local distance_to_targ = vector.distance(p,self._target)
 	--mcl_log("Distance to targ: ".. tostring(distance_to_targ))
-	if distance_to_targ < 2 then
+	if distance_to_targ < 1.5 then
 		mcl_log("Arrived at _target")
 		self.waypoints = nil
 		self._target = nil
@@ -400,6 +399,7 @@ function mob_class:check_gowp(dtime)
 			self:go_to_pos(self._current_target)
 		else
 			mcl_log("close to current target: ".. minetest.pos_to_string(self.current_target["pos"]))
+			mcl_log("target is: ".. minetest.pos_to_string(self._target))
 			self.current_target = nil
 		end
 
diff --git a/mods/ENTITIES/mobs_mc/villager.lua b/mods/ENTITIES/mobs_mc/villager.lua
index dcc16e16f..fc12899cd 100644
--- a/mods/ENTITIES/mobs_mc/villager.lua
+++ b/mods/ENTITIES/mobs_mc/villager.lua
@@ -1202,7 +1202,7 @@ local function get_ground_below_floating_object (float_pos)
 	until node.name ~= "air"
 
 	-- If pos is 1 below float_pos, then just return float_pos as there is no air below it
-	if pos.y == float_pos.y -1 then
+	if pos.y == float_pos.y - 1 then
 		--mcl_log("pos is only 1 lower than float pos so no air below")
 		return float_pos
 	else

From d6804bf4b7a7967df5f6614c5f6be17ab2dc42cd Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Fri, 30 Dec 2022 15:59:02 +0000
Subject: [PATCH 06/13] Fix distance to target issue, and refactor pathing
 actions

---
 mods/ENTITIES/mcl_mobs/pathfinding.lua | 39 ++++++++++++++------------
 1 file changed, 21 insertions(+), 18 deletions(-)

diff --git a/mods/ENTITIES/mcl_mobs/pathfinding.lua b/mods/ENTITIES/mcl_mobs/pathfinding.lua
index db58ff777..31b98bbba 100644
--- a/mods/ENTITIES/mcl_mobs/pathfinding.lua
+++ b/mods/ENTITIES/mcl_mobs/pathfinding.lua
@@ -63,28 +63,19 @@ local function generate_enriched_path(wp_in, door_open_pos, door_close_pos, cur_
 		local cur_pos_to_add = vector.add(cur_pos, one_down)
 		if door_open_pos and vector.equals (cur_pos, door_open_pos) then
 			mcl_log ("Door open match")
-			action = {type = "door", action = "open"}
-			--action = {}
-			--action["type"] = "door"
-			--action["action"] = "open"
-			action["target"] = cur_door_pos
+			action = {type = "door", action = "open", target = cur_door_pos}
+			--action["target"] = cur_door_pos
 			cur_pos_to_add = vector.add(cur_pos, one_down)
 		elseif door_close_pos and vector.equals(cur_pos, door_close_pos) then
 			mcl_log ("Door close match")
-			action = {type = "door", action = "close"}
-			--action = {}
-			--action["type"] = "door"
-			--action["action"] = "close"
-			action["target"] = cur_door_pos
+			action = {type = "door", action = "close", target = cur_door_pos}
+			--action["target"] = cur_door_pos
 			cur_pos_to_add = vector.add(cur_pos, one_down)
 		elseif cur_door_pos and vector.equals(cur_pos, cur_door_pos) then
 			mcl_log("Current door pos")
+			action = {type = "door", action = "open", target = cur_door_pos}
 			cur_pos_to_add = vector.add(cur_pos, one_down)
-			action = {type = "door", action = "open"}
-			--action = {}
-			--action["type"] = "door"
-			--action["action"] = "open"
-			action["target"] = cur_door_pos
+			--action["target"] = cur_door_pos
 		else
 			cur_pos_to_add = cur_pos
 			--mcl_log ("Pos doesn't match")
@@ -202,7 +193,7 @@ function mob_class:gopath(target,callback_arrived)
 	local wp = minetest.find_path(p,t,150,1,4)
 
 	if not wp then
-		mcl_log("No direct path. Path through door")
+		mcl_log("No direct path. Path through door closest to target.")
 		local cur_door_pos = minetest.find_node_near(target, 16, {"group:door"})
 		wp = calculate_path_through_door(p, t, cur_door_pos)
 
@@ -317,7 +308,7 @@ function mob_class:check_gowp(dtime)
 	-- arrived at location, finish gowp
 	local distance_to_targ = vector.distance(p,self._target)
 	--mcl_log("Distance to targ: ".. tostring(distance_to_targ))
-	if distance_to_targ < 1.5 then
+	if distance_to_targ < 1.8 then
 		mcl_log("Arrived at _target")
 		self.waypoints = nil
 		self._target = nil
@@ -328,6 +319,8 @@ function mob_class:check_gowp(dtime)
 		self.object:set_acceleration({x = 0, y = 0, z = 0})
 		if self.callback_arrived then return self.callback_arrived(self) end
 		return true
+	elseif not self.current_target then
+		mcl_log("Not close enough to targ: ".. tostring(distance_to_targ))
 	end
 
 	-- More pathing to be done
@@ -373,9 +366,19 @@ function mob_class:check_gowp(dtime)
 		-- Is a little sensitive and could take 1 - 7 times. A 10 fail count might be a good exit condition.
 
 		mcl_log("We don't have waypoints or a current target. Let's try to path to target")
+
+		if wp then
+			mcl_log("WP: " .. tostring(wp))
+			mcl_log("WP num: " .. tostring(#wp))
+		else
+			mcl_log("No wp set")
+		end
+
+		mcl_log("Current target: " .. tostring(self.current_target))
+
 		local final_wp = minetest.find_path(p,self._target,150,1,4)
 		if final_wp then
-			mcl_log("We might be able to get to target here.")
+			mcl_log("We can get to target here.")
 		--	self.waypoints = final_wp
 			self:go_to_pos(self._target)
 		else

From 4324fe24895774b45835124af37f1f1530b8f732 Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Sat, 31 Dec 2022 01:21:16 +0000
Subject: [PATCH 07/13] Villager will now path from one house to another in
 search of available job or bed

---
 mods/ENTITIES/mcl_mobs/pathfinding.lua | 131 ++++++++++++++++++-------
 1 file changed, 96 insertions(+), 35 deletions(-)

diff --git a/mods/ENTITIES/mcl_mobs/pathfinding.lua b/mods/ENTITIES/mcl_mobs/pathfinding.lua
index 31b98bbba..b92486465 100644
--- a/mods/ENTITIES/mcl_mobs/pathfinding.lua
+++ b/mods/ENTITIES/mcl_mobs/pathfinding.lua
@@ -42,7 +42,7 @@ local function output_enriched (wp_out)
 
 		local action =  outy["action"]
 		if action then
-			mcl_log("Pos ".. i ..":" .. minetest.pos_to_string(outy["pos"]))
+			--mcl_log("Pos ".. i ..":" .. minetest.pos_to_string(outy["pos"]))
 			mcl_log("type: " .. action["type"])
 			mcl_log("action: " .. action["action"])
 			mcl_log("target: " .. minetest.pos_to_string(action["target"]))
@@ -51,31 +51,33 @@ local function output_enriched (wp_out)
 	end
 end
 
+local one_down = vector.new(0,-1,0)
+local one_up = vector.new(0,1,0)
+
 -- This function will take a list of paths, and enrich it with:
 -- a var for failed attempts
 -- an action, such as to open or close a door where we know that pos requires that action
 local function generate_enriched_path(wp_in, door_open_pos, door_close_pos, cur_door_pos)
 	local wp_out = {}
+
+	local current_door_index = -1
+
 	for i, cur_pos in pairs(wp_in) do
 		local action = nil
 
-		local one_down = vector.new(0,-1,0)
 		local cur_pos_to_add = vector.add(cur_pos, one_down)
 		if door_open_pos and vector.equals (cur_pos, door_open_pos) then
 			mcl_log ("Door open match")
 			action = {type = "door", action = "open", target = cur_door_pos}
-			--action["target"] = cur_door_pos
 			cur_pos_to_add = vector.add(cur_pos, one_down)
 		elseif door_close_pos and vector.equals(cur_pos, door_close_pos) then
 			mcl_log ("Door close match")
 			action = {type = "door", action = "close", target = cur_door_pos}
-			--action["target"] = cur_door_pos
 			cur_pos_to_add = vector.add(cur_pos, one_down)
 		elseif cur_door_pos and vector.equals(cur_pos, cur_door_pos) then
 			mcl_log("Current door pos")
 			action = {type = "door", action = "open", target = cur_door_pos}
 			cur_pos_to_add = vector.add(cur_pos, one_down)
-			--action["target"] = cur_door_pos
 		else
 			cur_pos_to_add = cur_pos
 			--mcl_log ("Pos doesn't match")
@@ -100,8 +102,6 @@ local plane_adjacents = {
 	vector.new(0,0,-1),
 }
 
---local gopath_last = os.time()
-
 function mob_class:ready_to_path()
 	mcl_log("Check ready to path")
 	if self._pf_last_failed and (os.time() - self._pf_last_failed) < 30 then
@@ -113,22 +113,26 @@ function mob_class:ready_to_path()
 end
 
 -- This function is used to see if we can path. We could use to check a route, rather than making people move.
-local function calculate_path_through_door (p, t, cur_door_pos)
-	-- target is the same as t, just 1 square difference. Maybe we don't need target
-	mcl_log("Plot route from mob: " .. minetest.pos_to_string(p) .. ", to target: " .. minetest.pos_to_string(t))
+local function calculate_path_through_door (p, cur_door_pos, t)
+	if t then
+		mcl_log("Plot route through door from pos: " .. minetest.pos_to_string(p) .. ", to target: " .. minetest.pos_to_string(t))
+	else
+		mcl_log("Plot route through door from pos: " .. minetest.pos_to_string(p))
+	end
 
 	local enriched_path = nil
+	local wp, prospective_wp
 
-	--local cur_door_pos = nil
 	local pos_closest_to_door = nil
 	local other_side_of_door = nil
 
-	local wp, prospective_wp
-
 	if cur_door_pos then
 		mcl_log("Found a door near: " .. minetest.pos_to_string(cur_door_pos))
+
 		for _,v in pairs(plane_adjacents) do
 			pos_closest_to_door = vector.add(cur_door_pos,v)
+			other_side_of_door = vector.add(cur_door_pos,-v)
+
 			local n = minetest.get_node(pos_closest_to_door)
 
 			if n.name == "air" then
@@ -138,22 +142,34 @@ local function calculate_path_through_door (p, t, cur_door_pos)
 
 				if prospective_wp then
 					mcl_log("Found a path to next to door".. minetest.pos_to_string(pos_closest_to_door))
-					other_side_of_door = vector.add(cur_door_pos,-v)
 					mcl_log("Opposite is: ".. minetest.pos_to_string(other_side_of_door))
 
-					local wp_otherside_door_to_target = minetest.find_path(other_side_of_door,t,150,1,4)
-					if wp_otherside_door_to_target and #wp_otherside_door_to_target > 0 then
-						table.insert(prospective_wp, cur_door_pos)
-						append_paths (prospective_wp, wp_otherside_door_to_target)
-						enriched_path = generate_enriched_path(prospective_wp, pos_closest_to_door, other_side_of_door, cur_door_pos)
-						wp = prospective_wp
-						mcl_log("We have a path from outside door to target")
+					table.insert(prospective_wp, cur_door_pos)
+
+					if t then
+						mcl_log("We have t, lets go from door to target")
+						local wp_otherside_door_to_target = minetest.find_path(other_side_of_door,t,150,1,4)
+
+						if wp_otherside_door_to_target and #wp_otherside_door_to_target > 0 then
+							append_paths (prospective_wp, wp_otherside_door_to_target)
+
+							wp = prospective_wp
+							mcl_log("We have a path from outside door to target")
+						else
+							mcl_log("We cannot path from outside door to target")
+						end
 					else
-						mcl_log("We cannot path from outside door to target")
+						mcl_log("No t, just add other side of door")
+						table.insert(prospective_wp, other_side_of_door)
+						wp = prospective_wp
+					end
+
+					if wp then
+						enriched_path = generate_enriched_path(wp, pos_closest_to_door, other_side_of_door, cur_door_pos)
+						break
 					end
-					break
 				else
-					mcl_log("This block next to door doesn't work.")
+					mcl_log("Cannot path to this air block next to door.")
 				end
 			end
 		end
@@ -168,7 +184,7 @@ local function calculate_path_through_door (p, t, cur_door_pos)
 	return enriched_path
 end
 
-
+--local gopath_last = os.time()
 
 function mob_class:gopath(target,callback_arrived)
 	if self.state == PATHFINDING then mcl_log("Already pathfinding, don't set another until done.") return end
@@ -193,15 +209,55 @@ function mob_class:gopath(target,callback_arrived)
 	local wp = minetest.find_path(p,t,150,1,4)
 
 	if not wp then
-		mcl_log("No direct path. Path through door closest to target.")
-		local cur_door_pos = minetest.find_node_near(target, 16, {"group:door"})
-		wp = calculate_path_through_door(p, t, cur_door_pos)
+		mcl_log("### No direct path. Path through door closest to target.")
+		local door_near_target = minetest.find_node_near(target, 16, {"group:door"})
+		wp = calculate_path_through_door(p, door_near_target, t)
 
 		if not wp then
-			mcl_log("No path though door closest to target. Try door closest to origin.")
-			cur_door_pos = minetest.find_node_near(p, 16, {"group:door"})
-			wp = calculate_path_through_door(p, t, cur_door_pos)
+			mcl_log("### No path though door closest to target. Try door closest to origin.")
+			local door_closest = minetest.find_node_near(p, 16, {"group:door"})
+			wp = calculate_path_through_door(p, door_closest, t)
+
+			-- Path through 2 doors
+			if not wp then
+				mcl_log("### Still not wp. Need to path through 2 doors.")
+				local path_through_closest_door = calculate_path_through_door(p, door_closest)
+
+				if path_through_closest_door and #path_through_closest_door > 0 then
+					mcl_log("We have path through first door")
+					mcl_log("Number of pos in path through door: " .. tostring(#path_through_closest_door))
+
+					local pos_after_door_entry = path_through_closest_door[#path_through_closest_door]
+					if pos_after_door_entry then
+						local pos_after_door = vector.add(pos_after_door_entry["pos"], one_up)
+						mcl_log("pos_after_door: " .. minetest.pos_to_string(pos_after_door))
+						local path_after_door = calculate_path_through_door(pos_after_door, door_near_target, t)
+						if path_after_door and #path_after_door > 1 then
+							mcl_log("We have path after first door")
+							table.remove(path_after_door, 1) -- Remove duplicate
+							wp = path_through_closest_door
+							append_paths (wp, path_after_door)
+						else
+							mcl_log("Path after door is not good")
+						end
+					else
+						mcl_log("No pos after door")
+					end
+
+				else
+					mcl_log("Path through closest door empty or null")
+				end
+				-- Path to and through door
+				-- Path from otherside of door through door to next target
+			else
+				mcl_log("ok, we have a path through 1 door")
+			end
+
 		end
+
+		-- Path through door closest to target (starting at square before door)
+		-- Path to that starting point directly
+			-- or path through door to that starting point
 	else
 		wp = generate_enriched_path(wp)
 		mcl_log("We have a direct route")
@@ -367,14 +423,19 @@ function mob_class:check_gowp(dtime)
 
 		mcl_log("We don't have waypoints or a current target. Let's try to path to target")
 
-		if wp then
-			mcl_log("WP: " .. tostring(wp))
-			mcl_log("WP num: " .. tostring(#wp))
+		if self.waypoints then
+			mcl_log("WP: " .. tostring(self.waypoints))
+			mcl_log("WP num: " .. tostring(#self.waypoints))
 		else
 			mcl_log("No wp set")
 		end
 
-		mcl_log("Current target: " .. tostring(self.current_target))
+		if self.current_target then
+			mcl_log("Current target: " .. tostring(self.current_target))
+		else
+			mcl_log("No current target")
+		end
+
 
 		local final_wp = minetest.find_path(p,self._target,150,1,4)
 		if final_wp then

From e9b54e85c28a2a1d0f2a67c067035176b0b87db2 Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Sat, 31 Dec 2022 17:52:09 +0000
Subject: [PATCH 08/13] Pathfinding clean up

---
 mods/ENTITIES/mcl_mobs/pathfinding.lua | 28 ++++++++------------------
 1 file changed, 8 insertions(+), 20 deletions(-)

diff --git a/mods/ENTITIES/mcl_mobs/pathfinding.lua b/mods/ENTITIES/mcl_mobs/pathfinding.lua
index b92486465..273e9952d 100644
--- a/mods/ENTITIES/mcl_mobs/pathfinding.lua
+++ b/mods/ENTITIES/mcl_mobs/pathfinding.lua
@@ -1,16 +1,19 @@
 local math, vector, minetest, mcl_mobs = math, vector, minetest, mcl_mobs
 local mob_class = mcl_mobs.mob_class
 
-local LOGGING_ON = minetest.settings:get_bool("mcl_logging_mobs_villager",false)
+local LOGGING_ON = minetest.settings:get_bool("mcl_logging_mobs_pathfinding",false)
 local PATHFINDING = "gowp"
 
-local LOG_MODULE = "[Mobs]"
+local LOG_MODULE = "[Mobs Pathfinding]"
 local function mcl_log (message)
 	if LOGGING_ON and message then
 		minetest.log(LOG_MODULE .. " " .. message)
 	end
 end
 
+local one_down = vector.new(0,-1,0)
+local one_up = vector.new(0,1,0)
+
 function output_table (wp)
 	if not wp then return end
 	mcl_log("wp items: ".. tostring(#wp))
@@ -51,15 +54,13 @@ local function output_enriched (wp_out)
 	end
 end
 
-local one_down = vector.new(0,-1,0)
-local one_up = vector.new(0,1,0)
-
 -- This function will take a list of paths, and enrich it with:
 -- a var for failed attempts
 -- an action, such as to open or close a door where we know that pos requires that action
 local function generate_enriched_path(wp_in, door_open_pos, door_close_pos, cur_door_pos)
 	local wp_out = {}
 
+	-- TODO  Just pass in door position and the index before is open, the index after is close
 	local current_door_index = -1
 
 	for i, cur_pos in pairs(wp_in) do
@@ -105,6 +106,7 @@ local plane_adjacents = {
 function mob_class:ready_to_path()
 	mcl_log("Check ready to path")
 	if self._pf_last_failed and (os.time() - self._pf_last_failed) < 30 then
+		mcl_log("Not ready to path as last fail is less than threshold: " .. (os.time() - self._pf_last_failed))
 		return false
 	else
 		mcl_log("We are ready to pathfind, no previous fail or we are past threshold")
@@ -188,11 +190,7 @@ end
 
 function mob_class:gopath(target,callback_arrived)
 	if self.state == PATHFINDING then mcl_log("Already pathfinding, don't set another until done.") return end
-
-	if not self:ready_to_path() then
-		mcl_log("We are not ready to path as last fail is less than threshold: " .. (os.time() - self._pf_last_failed))
-		return
-	end
+	if not self:ready_to_path() then return end
 
 	--if os.time() - gopath_last < 5 then
 	--	mcl_log("Not ready to path yet")
@@ -243,28 +241,18 @@ function mob_class:gopath(target,callback_arrived)
 					else
 						mcl_log("No pos after door")
 					end
-
 				else
 					mcl_log("Path through closest door empty or null")
 				end
-				-- Path to and through door
-				-- Path from otherside of door through door to next target
 			else
 				mcl_log("ok, we have a path through 1 door")
 			end
-
 		end
-
-		-- Path through door closest to target (starting at square before door)
-		-- Path to that starting point directly
-			-- or path through door to that starting point
 	else
 		wp = generate_enriched_path(wp)
 		mcl_log("We have a direct route")
 	end
 
-	--path from pos to door, path from otherside to target
-
 	if not wp then
 		mcl_log("Could not calculate path")
 		self._pf_last_failed = os.time()

From 325a666c622e6a77ed9ae3f03ef4adbf2091d107 Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Sat, 31 Dec 2022 19:39:58 +0000
Subject: [PATCH 09/13] Added pathfinder constants to make it easier to tweak

---
 mods/ENTITIES/mcl_mobs/pathfinding.lua | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/mods/ENTITIES/mcl_mobs/pathfinding.lua b/mods/ENTITIES/mcl_mobs/pathfinding.lua
index 273e9952d..c8855364d 100644
--- a/mods/ENTITIES/mcl_mobs/pathfinding.lua
+++ b/mods/ENTITIES/mcl_mobs/pathfinding.lua
@@ -4,6 +4,9 @@ local mob_class = mcl_mobs.mob_class
 local LOGGING_ON = minetest.settings:get_bool("mcl_logging_mobs_pathfinding",false)
 local PATHFINDING = "gowp"
 
+local PATHFINDING_FAIL_THRESHOLD = 100 -- no. of ticks to fail before giving up. 20p/s. 5s helps them get through door
+local PATHFINDING_FAIL_WAIT = 30 -- how long to wait before trying to path again
+
 local LOG_MODULE = "[Mobs Pathfinding]"
 local function mcl_log (message)
 	if LOGGING_ON and message then
@@ -105,7 +108,7 @@ local plane_adjacents = {
 
 function mob_class:ready_to_path()
 	mcl_log("Check ready to path")
-	if self._pf_last_failed and (os.time() - self._pf_last_failed) < 30 then
+	if self._pf_last_failed and (os.time() - self._pf_last_failed) < PATHFINDING_FAIL_WAIT then
 		mcl_log("Not ready to path as last fail is less than threshold: " .. (os.time() - self._pf_last_failed))
 		return false
 	else
@@ -390,7 +393,7 @@ function mob_class:check_gowp(dtime)
 		-- No waypoints left, but have current target. Potentially last waypoint to go to.
 		self.current_target["failed_attempts"] = self.current_target["failed_attempts"] + 1
 		local failed_attempts = self.current_target["failed_attempts"]
-		if failed_attempts >= 50 then
+		if failed_attempts >= PATHFINDING_FAIL_THRESHOLD then
 			mcl_log("Failed to reach position (" .. minetest.pos_to_string(self.current_target["pos"]) .. ") too many times. Abandon route. Times tried: " .. failed_attempts)
 			self.state = "stand"
 			self.current_target = nil

From 465a919f6b77048c7cd9903ae5c3965f651976ec Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Sat, 31 Dec 2022 19:41:42 +0000
Subject: [PATCH 10/13] Villager will now reclaim job during the day even when
 it isn't work time

---
 mods/ENTITIES/mobs_mc/villager.lua | 136 +++++++++++++++--------------
 1 file changed, 70 insertions(+), 66 deletions(-)

diff --git a/mods/ENTITIES/mobs_mc/villager.lua b/mods/ENTITIES/mobs_mc/villager.lua
index fc12899cd..ce1e76c72 100644
--- a/mods/ENTITIES/mobs_mc/villager.lua
+++ b/mods/ENTITIES/mobs_mc/villager.lua
@@ -770,7 +770,7 @@ local function check_bed (entity)
 	local n = minetest.get_node(b)
 
 	local is_bed_bottom = string.find(n.name,"_bottom")
-	mcl_log("" .. tostring(is_bed_bottom))
+	--mcl_log("is bed bottom: " .. tostring(is_bed_bottom))
 	if n and not is_bed_bottom then
 		mcl_log("Where did my bed go?!")
 		entity._bed = nil --the stormtroopers have killed uncle owen
@@ -1135,59 +1135,54 @@ local function validate_jobsite(self)
 end
 
 local function do_work (self)
-	--debug_trades(self)
-	if self.child then
-		mcl_log("A child so don't send to work")
+
+	if not self or self.child then
+		mcl_log("No self, or a child so don't work")
 		return
 	end
+
 	--mcl_log("Time for work")
+	local jobsite_node = retrieve_my_jobsite (self)
 
-	-- Don't try if looking_for_work, or gowp possibly
-	if validate_jobsite(self) then
-		--mcl_log("My jobsite is valid. Do i need to travel?")
-
-		local jobsite2 = retrieve_my_jobsite (self)
+	if jobsite_node then
 		local jobsite = self._jobsite
 
-		if self and jobsite2 and self._jobsite then
-			local distance_to_jobsite = vector.distance(self.object:get_pos(),self._jobsite)
-			--mcl_log("Villager: ".. minetest.pos_to_string(self.object:get_pos()) ..  ", jobsite: " .. minetest.pos_to_string(self._jobsite) .. ", distance to jobsite: ".. distance_to_jobsite)
+		local distance_to_jobsite = vector.distance(self.object:get_pos(), jobsite)
+		--mcl_log("Villager: ".. minetest.pos_to_string(self.object:get_pos()) ..  ", jobsite: " .. minetest.pos_to_string(self._jobsite) .. ", distance to jobsite: ".. distance_to_jobsite)
 
-			if distance_to_jobsite < 2 then
-				if self.state ~= PATHFINDING and  self.order ~= WORK then
-					mcl_log("Setting order to work.")
-					self.order = WORK
-					unlock_trades(self)
-				else
-					--mcl_log("Still pathfinding.")
-				end
+		if distance_to_jobsite < 2 then
+			if self.state ~= PATHFINDING and  self.order ~= WORK then
+				mcl_log("Setting order to work.")
+				self.order = WORK
+				unlock_trades(self)
 			else
-				mcl_log("Not at job block. Need to commute.")
-				if self.order == WORK then
-					self.order = nil
-					return
-				end
-				self:gopath(jobsite, function(self,jobsite)
-					if not self then
-						--mcl_log("missing self. not good")
-						return false
-					end
-					if not self._jobsite then
-						--mcl_log("Jobsite not valid")
-						return false
-					end
-					if vector.distance(self.object:get_pos(),self._jobsite) < 2 then
-						--mcl_log("Made it to work ok callback!")
-						return true
-					else
-						--mcl_log("Need to walk to work. Not sure we can get here.")
-					end
-				end)
+				--mcl_log("Still pathfinding.")
 			end
+		else
+			mcl_log("Not at job block. Need to commute.")
+			if self.order == WORK then
+				self.order = nil
+				return
+			end
+			self:gopath(jobsite, function(self, jobsite)
+				if not self then
+					--mcl_log("missing self. not good")
+					return false
+				end
+				if not self._jobsite then
+					--mcl_log("Jobsite not valid")
+					return false
+				end
+				if vector.distance(self.object:get_pos(),self._jobsite) < 2 then
+					--mcl_log("Made it to work ok callback!")
+					return true
+				else
+					--mcl_log("Need to walk to work. Not sure we can get here.")
+				end
+			end)
 		end
-	elseif self._profession == "unemployed" or has_traded(self) then
-		get_a_job(self)
 	end
+
 end
 
 local below_vec = vector.new(0, -1, 0)
@@ -1214,17 +1209,10 @@ local function get_ground_below_floating_object (float_pos)
 end
 
 local function go_to_town_bell(self)
-	if self.order == GATHERING then
-		--mcl_log("Already gathering")
-		return
-	else
-		mcl_log("Current order" .. self.order)
-	end
+	if self.order == GATHERING then return
+	else mcl_log("Current order" .. self.order) end
 
-	if not self:ready_to_path() then
-		mcl_log("Negative response to go_path. Do not bother")
-		return
-	end
+	if not self:ready_to_path() then return end
 
 	mcl_log("Go to town bell")
 
@@ -1307,22 +1295,45 @@ local function validate_bed(self)
 end
 
 local function do_activity (self)
-	-- Maybe just check we're pathfinding first?
+
 	if self.following then
 		mcl_log("Following, so do not do activity.")
 		return
 	end
+	if self.state == PATHFINDING then
+		mcl_log("Pathfinding, so do not do activity.")
+		return
+	end
 
-	if not validate_bed(self) and self.state ~= PATHFINDING then
+	local jobsite_valid = false
+
+	if not mcl_beds.is_night() then
 		if self.order == SLEEP then self.order = nil end
-		mcl_log("Villager has no bed. Currently at location: "..minetest.pos_to_string(self.object:get_pos()))
-		take_bed (self)
+
+		if not validate_jobsite(self) then
+			--debug_trades(self)
+			if self._profession == "unemployed" or has_traded(self) then
+				get_a_job(self)
+				return
+			end
+		else
+			jobsite_valid = true
+			--mcl_log("My jobsite is valid. Do i need to travel?")
+		end
+	else
+		if self.order == WORK then self.order = nil end
+
+		if not validate_bed(self) then
+			if self.order == SLEEP then self.order = nil end
+			mcl_log("Villager at this location has no bed: " .. minetest.pos_to_string(self.object:get_pos()))
+			take_bed (self)
+		end
 	end
 
 	-- Only check in day or during thunderstorm but wandered_too_far code won't work
 	local wandered_too_far = false
 	if check_bed (self) then
-		wandered_too_far = ( self.state ~= PATHFINDING ) and (vector.distance(self.object:get_pos(),self._bed) > 50 )
+		wandered_too_far = vector.distance(self.object:get_pos(),self._bed) > 50
 	end
 
 	if wandered_too_far  then
@@ -1330,7 +1341,7 @@ local function do_activity (self)
 		go_home(self, false)
 	elseif get_activity() == SLEEP then
 		go_home(self, true)
-	elseif get_activity() == WORK then
+	elseif get_activity() == WORK and jobsite_valid then
 		do_work(self)
 	elseif get_activity() == GATHERING then
 		go_to_town_bell(self)
@@ -1339,13 +1350,6 @@ local function do_activity (self)
 		self.order = nil
 	end
 
-	-- Daytime is work and play time
-	if not mcl_beds.is_night() then
-		if self.order == SLEEP then self.order = nil end
-	else
-		if self.order == WORK then self.order = nil end
-	end
-
 end
 
 local function update_max_tradenum(self)

From 85f7bbdb807c5db1387a5d422b048cbc4d7ecf14 Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Sat, 31 Dec 2022 23:47:22 +0000
Subject: [PATCH 11/13] Optimisation. Don't even prepare to path if not ready
 to path

---
 mods/ENTITIES/mobs_mc/villager.lua | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/mods/ENTITIES/mobs_mc/villager.lua b/mods/ENTITIES/mobs_mc/villager.lua
index ce1e76c72..0cd3a6c52 100644
--- a/mods/ENTITIES/mobs_mc/villager.lua
+++ b/mods/ENTITIES/mobs_mc/villager.lua
@@ -836,6 +836,7 @@ end
 
 local function take_bed (entity)
 	if not entity then return end
+	if not self:ready_to_path() then return end
 
 	local p = entity.object:get_pos()
 
@@ -1059,9 +1060,9 @@ local function look_for_job(self, requested_jobsites)
 end
 
 
-
 local function get_a_job(self)
 	if self.order == WORK then self.order = nil end
+	if not self:ready_to_path() then return end
 
 	mcl_log("I'm unemployed or lost my job block and have traded. Can I get a job?")
 

From 2527479401aeaa3911e38975186e2140bf685620 Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Sat, 31 Dec 2022 23:48:15 +0000
Subject: [PATCH 12/13] Clean up on isle 5, please

---
 mods/ENTITIES/mcl_mobs/pathfinding.lua | 57 +++++++++-----------------
 1 file changed, 19 insertions(+), 38 deletions(-)

diff --git a/mods/ENTITIES/mcl_mobs/pathfinding.lua b/mods/ENTITIES/mcl_mobs/pathfinding.lua
index c8855364d..ee39d28ad 100644
--- a/mods/ENTITIES/mcl_mobs/pathfinding.lua
+++ b/mods/ENTITIES/mcl_mobs/pathfinding.lua
@@ -1,12 +1,23 @@
 local math, vector, minetest, mcl_mobs = math, vector, minetest, mcl_mobs
 local mob_class = mcl_mobs.mob_class
 
-local LOGGING_ON = minetest.settings:get_bool("mcl_logging_mobs_pathfinding",false)
-local PATHFINDING = "gowp"
-
 local PATHFINDING_FAIL_THRESHOLD = 100 -- no. of ticks to fail before giving up. 20p/s. 5s helps them get through door
 local PATHFINDING_FAIL_WAIT = 30 -- how long to wait before trying to path again
 
+local PATHFINDING = "gowp"
+
+local one_down = vector.new(0,-1,0)
+local one_up = vector.new(0,1,0)
+
+local plane_adjacents = {
+	vector.new(1,0,0),
+	vector.new(-1,0,0),
+	vector.new(0,0,1),
+	vector.new(0,0,-1),
+}
+
+local LOGGING_ON = minetest.settings:get_bool("mcl_logging_mobs_pathfinding",false)
+
 local LOG_MODULE = "[Mobs Pathfinding]"
 local function mcl_log (message)
 	if LOGGING_ON and message then
@@ -14,9 +25,6 @@ local function mcl_log (message)
 	end
 end
 
-local one_down = vector.new(0,-1,0)
-local one_up = vector.new(0,1,0)
-
 function output_table (wp)
 	if not wp then return end
 	mcl_log("wp items: ".. tostring(#wp))
@@ -26,7 +34,7 @@ function output_table (wp)
 end
 
 function append_paths (wp1, wp2)
-	mcl_log("Start append")
+	--mcl_log("Start append")
 	if not wp1 or not wp2 then
 		mcl_log("Cannot append wp's")
 		return
@@ -36,7 +44,7 @@ function append_paths (wp1, wp2)
 	for _,a in pairs (wp2) do
 		table.insert(wp1, a)
 	end
-	mcl_log("End append")
+	--mcl_log("End append")
 end
 
 local function output_enriched (wp_out)
@@ -99,13 +107,6 @@ local function generate_enriched_path(wp_in, door_open_pos, door_close_pos, cur_
 	return wp_out
 end
 
-local plane_adjacents = {
-	vector.new(1,0,0),
-	vector.new(-1,0,0),
-	vector.new(0,0,1),
-	vector.new(0,0,-1),
-}
-
 function mob_class:ready_to_path()
 	mcl_log("Check ready to path")
 	if self._pf_last_failed and (os.time() - self._pf_last_failed) < PATHFINDING_FAIL_WAIT then
@@ -189,18 +190,10 @@ local function calculate_path_through_door (p, cur_door_pos, t)
 	return enriched_path
 end
 
---local gopath_last = os.time()
-
 function mob_class:gopath(target,callback_arrived)
 	if self.state == PATHFINDING then mcl_log("Already pathfinding, don't set another until done.") return end
 	if not self:ready_to_path() then return end
 
-	--if os.time() - gopath_last < 5 then
-	--	mcl_log("Not ready to path yet")
-	--	return
-	--end
-	--gopath_last = os.time()
-
 	self.order = nil
 
 	local p = self.object:get_pos()
@@ -332,17 +325,7 @@ function mob_class:do_pathfind_action(action)
 	end
 end
 
-local gowp_etime = 0
-
 function mob_class:check_gowp(dtime)
-	gowp_etime = gowp_etime + dtime
-
-	-- 0.1 is optimal.
-	--less frequently = villager will get sent back after passing a point.
-	--more frequently = villager will fail points they shouldn't they just didn't get there yet
-
-	--if gowp_etime < 0.05 then return end
-	--gowp_etime = 0
 	local p = self.object:get_pos()
 
 	-- no destination
@@ -380,7 +363,7 @@ function mob_class:check_gowp(dtime)
 	-- 0.8 is optimal for 0.025 frequency checks and also 1... Actually. 0.8 is winning
 	-- 0.9 and 1.0 is also good. Stick with unless door open or closing issues
 	if self.waypoints and #self.waypoints > 0 and ( not self.current_target or not self.current_target["pos"] or distance_to_current_target < 0.9 ) then
-		-- We have waypoints, and no current target, or we're at it. We need a new current_target.
+		-- We have waypoints, and are at current_target or have no current target. We need a new current_target.
 		self:do_pathfind_action (self.current_target["action"])
 
 		local failed_attempts = self.current_target["failed_attempts"]
@@ -390,7 +373,8 @@ function mob_class:check_gowp(dtime)
 		self:go_to_pos(self.current_target["pos"])
 		return
 	elseif self.current_target and self.current_target["pos"] then
-		-- No waypoints left, but have current target. Potentially last waypoint to go to.
+		-- No waypoints left, but have current target and not close enough. Potentially last waypoint to go to.
+
 		self.current_target["failed_attempts"] = self.current_target["failed_attempts"] + 1
 		local failed_attempts = self.current_target["failed_attempts"]
 		if failed_attempts >= PATHFINDING_FAIL_THRESHOLD then
@@ -420,14 +404,12 @@ function mob_class:check_gowp(dtime)
 		else
 			mcl_log("No wp set")
 		end
-
 		if self.current_target then
 			mcl_log("Current target: " .. tostring(self.current_target))
 		else
 			mcl_log("No current target")
 		end
 
-
 		local final_wp = minetest.find_path(p,self._target,150,1,4)
 		if final_wp then
 			mcl_log("We can get to target here.")
@@ -457,7 +439,6 @@ function mob_class:check_gowp(dtime)
 			mcl_log("target is: ".. minetest.pos_to_string(self._target))
 			self.current_target = nil
 		end
-
 		return
 	end
 end

From e4db91d35c4b6f8dfec11b5153fc32096f7540dc Mon Sep 17 00:00:00 2001
From: ancientmarinerdev <ancientmariner_dev@proton.me>
Date: Sun, 1 Jan 2023 03:19:45 +0000
Subject: [PATCH 13/13] Fix crash bug

---
 mods/ENTITIES/mobs_mc/villager.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mods/ENTITIES/mobs_mc/villager.lua b/mods/ENTITIES/mobs_mc/villager.lua
index 0cd3a6c52..bb23758c5 100644
--- a/mods/ENTITIES/mobs_mc/villager.lua
+++ b/mods/ENTITIES/mobs_mc/villager.lua
@@ -836,7 +836,7 @@ end
 
 local function take_bed (entity)
 	if not entity then return end
-	if not self:ready_to_path() then return end
+	if not entity:ready_to_path() then return end
 
 	local p = entity.object:get_pos()