Move objects even when sticky blocks are involved

mesecons_mvps/init.lua

@@ -253,6 +253,52 @@ function mesecon.mvps_push_or_pull(pos, stackdir, movedir, maximum, all_pull_sti
 	return true, nodes, oldstack
 end
 
+-- Returns whether the given area intersects any nodes in the given set of position hashes,
+-- or any walkable nodes in the map if no set is given.
+local function area_intersects_nodes(min_pos, max_pos, positions)
+	min_pos = vector.round(min_pos)
+	max_pos = vector.round(max_pos)
+	local pos = vector.new(min_pos)
+	while pos.x <= max_pos.x do
+		while pos.y <= max_pos.y do
+			while pos.z <= max_pos.z do
+				if positions then
+					if positions[minetest.hash_node_position(pos)] then
+						return true
+					end
+				else
+					local def = minetest.registered_nodes[minetest.get_node(pos).name]
+					if not def or def.walkable then
+						return true
+					end
+				end
+				pos.z = pos.z + 1
+			end
+			pos.z = min_pos.z
+			pos.y = pos.y + 1
+		end
+		pos.y = min_pos.y
+		pos.x = pos.x + 1
+	end
+	return false
+end
+
+-- Returns whether the given area intersects the node face with the given normal axis and center point.
+local function area_intersects_face(min_pos, max_pos, normal_axis, center)
+	for k, v in pairs(center) do
+		if k == normal_axis then
+			if min_pos[k] >= v or max_pos[k] <= v then
+				return false
+			end
+		else
+			if min_pos[k] >= v + 0.5 or max_pos[k] <= v - 0.5 then
+				return false
+			end
+		end
+	end
+	return true
+end
+
 function mesecon.mvps_move_objects(pos, dir, nodestack, movefactor)
 	local dir_k
 	local dir_l
@@ -265,42 +311,61 @@ function mesecon.mvps_move_objects(pos, dir, nodestack, movefactor)
 	end
 	movefactor = movefactor or 1
 	dir = vector.multiply(dir, movefactor)
-	for id, obj in pairs(minetest.get_objects_inside_radius(pos, #nodestack + 1)) do
+	-- The collision box min and max positions will be extended by these values.
+	-- These small scalars are so that objects next to the moved stack are also moved.
+	local extension_min = vector.new(-0.01, -0.01, -0.01)
+	local extension_max = vector.new(0.01, 0.01, 0.01)
+	-- The collision box is extended in one direction to account for node displacement,
+	-- except in the special case where no nodes are moved.
+	local extension = nodestack[1] ~= nil and -dir[dir_k] or 0
+	if extension < 0 then
+		extension_min[dir_k] = extension
+		extension_max[dir_k] = 0
+	else
+		extension_min[dir_k] = 0
+		extension_max[dir_k] = extension
+	end
+
+	local max_distance = 0
+	local moved_positions, face_center
+	if movefactor == 1 or nodestack[1] ~= nil then
+		-- Usually, objects are moved if they intersect with moved node positions.
+		moved_positions = {}
+		if nodestack[1] == nil then
+			-- Push objects intersecting the mvps position.
+			moved_positions[minetest.hash_node_position(pos)] = true
+		end
+		for _, n in ipairs(nodestack) do
+			moved_positions[minetest.hash_node_position(n.pos)] = true
+			max_distance = math.max(max_distance, vector.distance(pos, n.pos))
+		end
+	else
+		-- When zero nodes are retracted, objects are moved if they intersect with the retracting face.
+		face_center = vector.new(pos)
+		face_center[dir_k] = face_center[dir_k] - 0.5 * dir_l
+	end
+
+	for id, obj in pairs(minetest.get_objects_inside_radius(pos, max_distance + 2)) do
 		local obj_pos = obj:get_pos()
 		local cbox = obj:get_properties().collisionbox
-		local min_pos = vector.add(obj_pos, vector.new(cbox[1], cbox[2], cbox[3]))
-		local max_pos = vector.add(obj_pos, vector.new(cbox[4], cbox[5], cbox[6]))
-		local ok = true
-		for k, v in pairs(pos) do
-			local edge1, edge2
-			if k ~= dir_k then
-				edge1 = v - 0.51 -- More than 0.5 to move objects near to the stack.
-				edge2 = v + 0.51
-			else
-				edge1 = v - 0.5 * dir_l
-				edge2 = v + (#nodestack + 0.5 * movefactor) * dir_l
-				-- Make sure, edge1 is bigger than edge2:
-				if edge1 > edge2 then
-					edge1, edge2 = edge2, edge1
-				end
-			end
-			if min_pos[k] > edge2 or max_pos[k] < edge1 then
-				ok = false
-				break
-			end
+		local min_pos = vector.add(obj_pos, vector.offset(extension_min, cbox[1], cbox[2], cbox[3]))
+		local max_pos = vector.add(obj_pos, vector.offset(extension_max, cbox[4], cbox[5], cbox[6]))
+		local ok
+		if moved_positions then
+			ok = area_intersects_nodes(min_pos, max_pos, moved_positions)
+		else
+			ok = area_intersects_face(min_pos, max_pos, dir_k, face_center)
 		end
 		if ok then
 			local ent = obj:get_luaentity()
 			if obj:is_player() or (ent and not mesecon.is_mvps_unmov(ent.name)) then
-				local np = vector.add(obj_pos, dir)
 				-- Move only if destination is not solid or object is inside stack:
-				local nn = minetest.get_node(np)
-				local node_def = minetest.registered_nodes[nn.name]
-				local obj_offset = dir_l * (obj_pos[dir_k] - pos[dir_k])
-				if (node_def and not node_def.walkable) or
-						(obj_offset >= 0 and
-						obj_offset <= #nodestack - 0.5) then
-					obj:move_to(np)
+				-- (A small bias is added to prevent rounding issues.)
+				local min_pos = vector.offset(obj_pos, cbox[1] + 0.01, cbox[2] + 0.01, cbox[3] + 0.01)
+				local max_pos = vector.offset(obj_pos, cbox[4] - 0.01, cbox[5] - 0.01, cbox[6] - 0.01)
+				if not area_intersects_nodes(vector.add(min_pos, dir), vector.add(max_pos, dir)) or
+						(nodestack[1] ~= nil and area_intersects_nodes(min_pos, max_pos, moved_positions)) then
+					obj:move_to(vector.add(obj_pos, dir))
 				end
 			end
 		end