This pathfinding code using the C* algorithm isn't working, and getting no errors?

I admittedly got this code from a youtube video ( link ) and it was made in 2016 meaning it's a bit outdated, but I thought it was still useful to try and get the C* algorithm, except when I tested it, the NPC did not move, at all. It produces no errors and still prints "Connected". I have no idea what is causing this. If anybody knows the solutions PLEASE help

Workspace Script:

local workSpace = game:GetService("Workspace")
local nodes = workSpace:WaitForChild("Nodes")
local Table = nodes:GetChildren()

function Connect()
	print("Connected")
	for _,A in ipairs(Table) do
		if #A:GetChildren() <= 0 then
			for _,B in ipairs(Table) do
				if B ~= A then
					local P = workSpace:FindPartOnRay(Ray.new(A.Position), B.Position - A.Position)
					
					if P == B then
						local neigbor = Instance.new("ObjectValue")
						neigbor.Value = B
						neigbor.Name = "Neighbor"
						neigbor.Parent = A
					end
				end
			end
		end
	end
end

Connect()

Script inside of NPC:

local pathfinder = require(game:GetService("ReplicatedStorage"):WaitForChild("A*"))

local torso = script.Parent:WaitForChild("HumanoidRootPart")
local humanoid = script.Parent:WaitForChild("Humanoid")

function follow_path(goal)
	if not goal then return end
	local path = pathfinder(torso.Position, goal)
	for _,node in ipairs(path) do
		repeat wait()
			humanoid:MoveTo(node)
		until (node - torso.Position).Magnitude <= 4
	end
end

function getClosestPlayer(to)
	local distance = math.huge
	local output = nil
	for _,player in ipairs(game:GetService("Players"):GetPlayers()) do
		local diff = player:DistanceFromCharacter(to)
		if diff < distance and player.Character then
			distance = diff
			output = player.Character	
		end	
	end
	return output
end

while wait() do
	
	local player = getClosestPlayer(torso.Position)
	if player and player:FindFirstChild("Torso") then
		follow_path(player.Torso.Position)
	end
end

script inside of replicated storage:

local Nodes = workspace:WaitForChild("Nodes")
local Table = Nodes:GetChildren()
local index = {}

local Parent	= {}
local gScore	= {}
local fScore	= {}

function Dec(Number)
	local Ceil = math.ceil(Number)
	
	if Ceil - Number <= .5 then
		return Ceil
	else
		return math.floor(Number)
	end
end

function SortUp(Table, Index)
	while true do
		local parentIndex = Dec((Index-1) / 2)
		if parentIndex == 0 then return Table end
		if fScore[Table[parentIndex]] > fScore[Table[Index]] then
			Table[parentIndex], Table[Index] = Table[Index], Table[parentIndex]
			Index = parentIndex
		else
			return Table
		end
	end
end

function Length(A, B)
	if not A or not B then return math.huge end
	return (A.Position - B.Position).Magnitude
end

function ClosestNode(Coord)
	local Output = nil
	local Cap = math.huge
	for _,v in ipairs(Table)do
		local Distance = (v.Position - Coord).Magnitude
		if Distance < Cap then
			Output = v
			Cap = Distance
		end
	end
	
	return Output
end

function FindIndexOf(Value, In)
	local Directory = index[In]
	if not Directory then
		index[In] = {}
		-- No reason to look for it if the table doesn't even exist.
		return index[In]
	end
	
	return Directory
end

function A_Star(A, B)
	local A = ClosestNode(A)
	local B = ClosestNode(B)
	
	local ClosedList 	= {}
	local OpenList		= {A}
	local Current
	
	Parent	= {}
	gScore	= {}
	fScore	= {}
	
	gScore[A] = 0
	fScore[A] = Length(A, B)
	Parent[A] = A
	
	repeat
		Current = OpenList[1]
		
		if Current == B then
			break
		end
		
		table.remove(OpenList, 1)
		ClosedList[Current] = Parent[Current]
		
		for _,v in ipairs(Current:GetChildren())do
			if v:IsA("ObjectValue") then
				local Node = v.Value
				
				local H = Length(Node, B)
				local G = gScore[Current] + Length(Current, Node)
				local F = G + H
				
				if not Parent[Node] and not ClosedList[Node] then
					Parent[Node] = Current
					fScore[Node] = F
					gScore[Node] = G
					table.insert(OpenList, Node)
					OpenList = SortUp(OpenList, #OpenList)
				end
				if G < gScore[Node] then
					Parent[Node] = Current
					gScore[Node] = G
					fScore[Node] = F
				end
			end
		end
	until #OpenList <= 0

	if #OpenList <= 0 then
		-- No path.
		return {}
	end
	
	-- Retrace path.
	local Path = {Current}
	Current = Parent[Current]
	repeat
		if Current then
			table.insert(Path, Current)
			if Parent[Current] == Current then
				break
			end
			Current = Parent[Current]
		end
	until not Current
	
	local Output = {}
	-- Reverse path.
	for i = #Path, 1, -1 do
		table.insert(Output, Path[i].Position)
	end
	if Current then
		return Output
	end
end

return A_Star