Could someone explain some of this Pathfinding code?

We'll start off by developing a simpler bit of code and then work towards this one.

Throughout this answer we will be using the Roblox PathfindingService. The wiki has a great tutorial for it here.

To start, we will create a program that will attempt to generate a path between two parts: a start node and a finish node. These 'nodes' will simply be parts (or and array of positions) that will tell us information on where the path should start at and be attempting to go.

But how to we create a path? There are two functions that will generate an array of positions between two of our nodes. There is ComputeRawPathAsync (a little faster) and ComputeSmoothPathAsync (a little slower). The raw path will be in more of a grid, where as the smooth path will try to curve the turns to make it a little smoother. Try both of them out to see the difference for your self!

local Pathfinding = game:GetService("PathfindingService")

local nodes = {
	game.Workspace.StartNode,
	game.Workspace.FinishNode,
}

local path = Pathfinding:ComputeSmoothAsync(nodes[1], nodes[2], 500)

Now that we've got the path generated, we have to check to see if the path is complete or not. If the path can be completed it will set the property Statusto Enum.PathStatus.Success. So we can do a quick little if statement to check if the path is good to use. Also, you might want to check out the other PathStatus enums as there is couple different statuses that could be useful.

if path.Status == Enum.PathStatus.Success then

else
	warn("Path creation unsuccessful")
end

Now we can do what ever we want with the path. For example, you could have an NPC follow the path but getting the points from the path using the GetPointCoordinates function:

local humanoid = game.Workspace.NPC.Humanoid
local points = path:GetPointCoordinates()

for _, point in ipairs (points) do
	humanoid:MoveTo(point)
	repeat
		local distance = (point - humanoid.Torso.Position).magnitude
		wait()
	until distance <= 3
end

Full Script (only runs once):

local Pathfinding = game:GetService("PathfindingService")

local nodes = {
	game.Workspace.StartNode,
	game.Workspace.FinishNode,
}

local path = Pathfinding:ComputeSmoothAsync(nodes[1], nodes[2], 500)

if path.Status == Enum.PathStatus.Success then
	local humanoid = game.Workspace.NPC.Humanoid
	local points = path:GetPointCoordinates()
	
	for _, point in ipairs (points) do
		humanoid:MoveTo(point)
		repeat
			local distance = (point - humanoid.Torso.Position).magnitude
			wait()
		until distance <= 3
	end
else
	warn("Path creation unsuccessful")
end

What the script you posted does

The script you posted uses all of what I just taught you but instead generates a coroutine for every player which selects a random node in the world and makes the player move towards that node.

There are some other things in here that help to prevent certain glitches from happening, like the lines 17-23 which place the points on the ground so that they aren't floating and potentially causing errors, and line 47 where it moves the character 5 studs backwards incase it gets stuck.

What I am going to do is break up this script into sections and attempt to make it more readable and easier to understand.

Script Setup

This is pretty straight forward. I did however change spawn to coroutine.wrap so that you could catch errors on the thread. I have also made it so that all the NPCs must be stored in an object called "NPCs" in workspace and all the nodes must be stored in an object called "Nodes".

local Pathfinding = game:GetService("PathfindingService")

local nodes = game.Workspace.Nodes:GetChildren()

for _, NPC in pairs (game.Workspace.NPCs:GetChildren()) do
	local error = coroutine.wrap(function()
		
		-- All the code will be in here

	end)
	if error then
		error(error)
	end
end

Setting Points on the ground:

This function works by casting a ray down 10 studs from each point in the path. If a part is hit, then it sets the position of the point to the hit position resulting in the new position sitting on the ground. This is useful for preventing the character from getting stuck in certain situations and for detecting when the player needs to jump.

local function SetPointsOnGround(path)
	local points = path:GetPointCoordinates()
	
	for key, point in pairs (points) do
		local part, position = game.Workspace:FindPartOnRay(Ray.new(point, Vector3.new(0, -10, 0)))
		
		if part then
			points[key] = position
		end
	end
	
	return points
end

Moving Character:

This function simply loops through all the points and moves the player towards them. While the player is moving, a repeat loop checks to see how far away the player is from the point, if the player needs to jump, and if the player is stuck and should break out of the loop.

local function MoveCharacter(points, humanoid)
	local shouldBreak = false
	for _, point in ipairs (points) do
		if shouldBreak then
			break
		end
		
		humanoid:MoveTo(point)

		local count = 0
		repeat
			local distance = (point - humanoid.Torso.Position).magnitude
			
			if point.Y > humanoid.Torso.Position.Y - 1 then
				humanoid.Jump = true
			end
			
			if count >= 50 then
				shouldBreak = true
				break
			end
			
			count = count + 1
			wait()
		until distance <= 4
	end
end

While Loop:

This is the main portion. This is what creates the path and calls the function to make the humanoid move. If the player is in a spot where it can not generate a path, it will attempt to move backwards 5 studs.

while true do
	local target = nodes[math.random(1, #nodes)]
	local path = Pathfinding:ComputeSmoothPathAsync(NPC.Torso.Position, target.Position, 500)
	
	if path.Status == Enum.PathStatus.Success then
		local points = SetPointsOnGround(path)
		MoveCharacter(points, NPC.Humanoid)
	else
		NPC.Humanoid:MoveTo(NPC.Humanoid.CFrame*Vector3.new(0, 0, 5))
	end
	
	wait()
end

Full Script:

local Pathfinding = game:GetService("PathfindingService")

local nodes = game.Workspace.Nodes:GetChildren()

for _, NPC in pairs (game.Workspace.NPCs:GetChildren()) do
	local error = coroutine.wrap(function()
		local function SetPointsOnGround(path)
			local points = path:GetPointCoordinates()
			
			for key, point in pairs (points) do
				local part, position = game.Workspace:FindPartOnRay(Ray.new(point, Vector3.new(0, -10, 0)))
				
				if part then
					points[key] = position
				end
			end
			
			return points
		end
		
		local function MoveCharacter(points, humanoid)
			local shouldBreak = false
			for _, point in ipairs (points) do
				if shouldBreak then
					break
				end
				
				humanoid:MoveTo(point)

				local count = 0
				repeat
					local distance = (point - humanoid.Torso.Position).magnitude
					
					if point.Y > humanoid.Torso.Position.Y - 1 then
						humanoid.Jump = true
					end
					
					if count >= 50 then
						shouldBreak = true
						break
					end
					
					count = count + 1
					wait()
				until distance <= 4
			end
		end
		
		while true do
			local target = nodes[math.random(1, #nodes)]
			local path = Pathfinding:ComputeSmoothPathAsync(NPC.Torso.Position, target.Position, 500)
			
			if path.Status == Enum.PathStatus.Success then
				local points = SetPointsOnGround(path)
				MoveCharacter(points, NPC.Humanoid)
			else
				NPC.Humanoid:MoveTo(NPC.Humanoid.CFrame*Vector3.new(0, 0, 5))
			end
			
			wait()
		end
	end)
	if error then
		error(error)
	end
end