Home Roblox Roblox Pathfinding - How To Find The Smallest And Smartest Path In...

Roblox Pathfinding – How To Find The Smallest And Smartest Path In Roblox?

Roblox is a platform to play games as well as make them. This platform has witnessed many great game developers as well as players. Many games have more than 500 million views to explain how big this platform is. There are millions of games in Roblox, featuring simulators, Prison Escape games, Disaster Survival game, or Breaking Point game. Roblox Studios is used to make the games over this platform.

Roblox Pathfinding is the shortest and smartest way of finding the routes between two points. If your game contains NPCs, these Pathfinding algorithms can make the NPC move efficiently between the points. You can use several algorithms, like Dijkstra’s algorithm, to find paths between the points. But in all cases, the default Pathfinding object has proved to be most efficient in deducing the routes between two points in the game.

What is Roblox Pathfinding?

Roblox Pathfinding Tutorial

In coding, there are famous ways of optimizing the path between two points in the graphs. These algorithms are fundamental in scenarios like Google Maps, Game Pathways, etc. In Roblox, you can move between the two points on the map efficiently using Roblox Pathfinding. This prebuilt object allows you to use the developers’ AI system to move between two points in the game.

Unlike other games, Roblox Pathfinding doesn’t require any prior knowledge about algorithms. You can just put any two points in the space and apply the object. This flexibility allows the budding developers to use them and move the characters as required easily.

Syntax of Roblox Pathfinding

The syntax of Roblox Pathfinding is straightforward and is only one-liner. With the use of syntax mentioned below, you can instantiate the Pathfinding in a variable.

global PathFindingObject = game:GetService("PathfindingService")

Now you can use Roblox PathFindingObject to apply the points and get the distances between those points. Afterward, you can create a Path object with the parameters listed below –

global path_objects = PathFindingObject:CreatePath(params)

The params section can be added with the following attributes –

KeyDatatypeDefault ValueExplanation
AgentRadiusInteger2Size of your Humanoid object. Pathfinding will make sure that your Humanoid can pass through objects before calculating the path.
AgentHeightInteger5Height of your Humanoid object. Pathfinding will take care of finding the path that has enough space for your Humanoid to pass.
AgentCanJumpBooleanTrueDecides whether your off-mesh jumping is allowed or not. For false, it will select a path where you can walk and reach.

Methods of Roblox Pathfinding

The following code makes the use of a Roblox Pathfinding algorithm to find a path for a Humanoid. A good path is a path in which your Humanoid doesn’t die while traveling.

local PathfindingObject = game:GetService("PathfindingService")
 
-- Variables for the zombie, its humanoid, and destination
local zombie = game.Workspace.Zombie
local human = zombie.Humanoid
local destination = game.Workspace.PinkFlag
 
-- Create the path object
local path = PathfindingObject:CreatePath()

In this example, we first create an object Zombie and get its Humanoid. Then we fetch the location of the Pink flag. After choosing the starting point and destination, the Pathfinding object will automatically find a path between them and store it in the variable path.

Getting The Efficient Path

When finding the efficient path, just creating the path object will not get you the path. You have to use the ComputeAsync method to find the path between two passing points.

Roblox Pathfinding Code 1
local PathfindingObject = game:GetService("PathfindingService")
 
-- Variables for the zombie, its humanoid, and destination
local zombie = game.Workspace.Zombie
local human = zombie.Humanoid
local destination = game.Workspace.PinkFlag
 
-- Create the path object
local path = PathfindingObject:CreatePath()

-- Compute path
path:ComputeAsync(zombie.HumanoidRootPart.Position, destination.PrimaryPart.Position)

The ComputeAsync method will compute the most efficient path between the two points passed as a parameter. This async function works in the background, and you can execute other things while the script calculates the path.

Getting Path Waypoints

Then use the GetWaypoints method to get the path that has been computed. These waypoints are the series of points in your path you need to take to reach the destination.

Pathfinding Code 2
local PathfindingObject = game:GetService("PathfindingService")
 
-- Variables for the zombie, its humanoid, and destination
local zombie = game.Workspace.Zombie
local human = zombie.Humanoid
local destination = game.Workspace.PinkFlag
 
-- Create the path object
local path = PathfindingObject:CreatePath()

-- Compute path
path:ComputeAsync(zombie.HumanoidRootPart.Position, destination.PrimaryPart.Position)

-- Receive the waypoints
local waypoints = path:GetWaypoints()
Pathfinding Roblox Basics

After computing the waypoints, you can fetch the waypoints by calling the GetWaypoints method. This method will return you with an array of waypoints between the given path.

Displaying the Waypoints

You can loop through the waypoints to display them. In the example below, we’ll highlight the path be spawning neon balls.

Pathfinding Displaying Path
local PathfindingObject = game:GetService("PathfindingService")
 
-- Variables for the zombie, its humanoid, and destination
local zombie = game.Workspace.Zombie
local human = zombie.Humanoid
local destination = game.Workspace.PinkFlag
 
-- Create the path object
local path = PathfindingObject:CreatePath()

-- Compute path
path:ComputeAsync(zombie.HumanoidRootPart.Position, destination.PrimaryPart.Position)

-- Receive the waypoints
local waypoints = path:GetWaypoints()

-- Loop through waypoints
for _, waypoint in pairs(waypoints) do
	local ball = Instance.new("Part")
	ball.Shape = "Ball"
	ball.Material = "Neon"
	ball.Size = Vector3.new(0.6, 0.6, 0.6)
	ball.Position = waypoint.Position
	ball.Anchored = true
	ball.CanCollide = false
	ball.Parent = game.Workspace
end

Moving in the Path

The last step in this process is to move the Humanoid. We’ll use the MoveTo method of humanoid to reach the points and travel along the path.

Roblox Pathfinding Moving Between objects
local PathfindingObject = game:GetService("PathfindingService")
 
-- Variables for the zombie, its humanoid, and destination
local zombie = game.Workspace.Zombie
local human = zombie.Humanoid
local destination = game.Workspace.PinkFlag
 
-- Create the path object
local path = PathfindingObject:CreatePath()

-- Compute path
path:ComputeAsync(zombie.HumanoidRootPart.Position, destination.PrimaryPart.Position)

-- Receive the waypoints
local waypoints = path:GetWaypoints()

-- Loop through waypoints
for _, waypoint in pairs(waypoints) do
	local ball = Instance.new("Part")
	ball.Shape = "Ball"
	ball.Material = "Neon"
	ball.Size = Vector3.new(0.6, 0.6, 0.6)
	ball.Position = waypoint.Position
	ball.Anchored = true
	ball.CanCollide = false
	ball.Parent = game.Workspace
        -- Move the Humanoid
	humanoid:MoveTo(waypoint.Position)
	-- Wait for the Humanoid to reach the position
	humanoid.MoveToFinished:Wait()
end

In this code section, we’ll loop through the waypoints array created by Roblox Pathfinding and spawn a Neon ball at every waypoint of the path. This will serve as the same route for the Humanoid. Next, we’ll use the MoveTo method of Humanoid to reach the destination. But in some cases, there might be some blocked paths in the way. We’ll handle those paths in the next section.

Roblox Pathfinding Final Code

Handle Blocked Paths With The Help Of Roblox Pathfinding

In finding the paths, there are many obstacles in the way. These obstacles may stop you from crossing certain points. So how do we take care of such situations? It’s simple; you just need to create an obstacle hander for your path. This will handle the cases where your paths are blocked. Roblox Pathfinding will create the best possible way for your path, but some objects might interfere with the path in a dynamic world.

local function followPath(destinationObject)
	-- Compute and check the path
	path:ComputeAsync(zombie.HumanoidRootPart.Position, destinationObject.PrimaryPart.Position)
	-- Empty waypoints table after each new path computation
	waypoints = {}
 
	if path.Status == Enum.PathStatus.Success then
		-- Get the path waypoints and start zombie walking
		waypoints = path:GetWaypoints()
		-- Move to first waypoint
		currentWaypointIndex = 1
		humanoid:MoveTo(waypoints[currentWaypointIndex].Position)
	else
		-- Error (path not found); stop humanoid
		humanoid:MoveTo(zombie.HumanoidRootPart.Position)
	end
end

local function onPathBlocked(blockedWaypointIndex)
	-- Check if the obstacle is further down the path
	if blockedWaypointIndex > currentWaypointIndex then
		-- Call function to re-compute the path
		followPath(destination)
	end
end
 
-- Connect 'Blocked' event to the 'onPathBlocked' function
path.Blocked:Connect(onPathBlocked)

At first, we created a function called onPathBlocked. This function handles the situation where your Humanoid faces an obstacle. This function checks if the blocked waypoint is ahead of the current waypoint. If this is true, then it calls the follow path function to re-compute the path. After recomputing, it follows the new path to the destination.

Final Words

Roblox Pathfinding has provided some best ways to reduce our coding task and save energy in developing the game. The developers have really created a masterpiece of Lua for the game development in Roblox. There are tons of Lua tutorials available on Roblox’s developer website, and they are increasing them to make sure everybody should be able to create games easily.

Most Popular

Roblox Skate Park Codes [2021]

Roblox is a web-based gaming stage where there are a ton of games accessible. It is accessible on PC just as on...

How to Send Gratitude with Flowers Animal Crossing?

We undoubtedly say that you will bring a smile to someone's face when you send some gratitude with flowers! And Animal Crossing...

How to get Log Stakes in Animal Crossing and Use Them?

The Animal Crossing computer game arrangement is a progression of correspondence reproduction games solely for Nintendo supports (aside from Pocket Camp, a...

Isabelle Animal Crossing Complete Character Guide

Animal Crossing is one of the famous social stimulation online video game series that the gaming community loves. It is developed...