All Classes and Interfaces
Class
Description
Provides a skeletal implementation of the
Pathfinder interface, defining common behavior
for pathfinding algorithms.An A* pathfinding algorithm that uses a heuristic to guide the search toward the target.
Represents a cost value used in pathfinding.
A processor that calculates a specific cost contribution for traversing to a node (PathPosition).
Represents the depth of a pathfinding node or element.
Computes a distance metric for the current state of a pathfinding operation.
A marker interface to implement, to provide environment-specific information to the Pathfinder.
Provides context for the evaluation of a single node (PathPosition) during a pathfinding search.
An immutable context object used for heuristic calculations providing the essentials.
A util class to provide the two predefined
IHeuristicStrategys of Pathetic.Represents a set of weights used to calculate a heuristic for the A* pathfinding algorithm.
Defines the contract for heuristic strategies used in pathfinding algorithms.
A functional interface to provide an offset as a
Iterable consisting of PathVectors.Utility class that provides methods for working with Iterables.
A linear heuristic strategy combining multiple distance metrics for pathfinding.
Contract for min-heap implementations used in pathfinding algorithms.
Represents information about a position in the pathfinding environment.
The NavigationPointProvider interface defines methods for retrieving navigation point data at
specific positions within a 3D environment.
This class serves as a util class in order to access Pathetic's predefined
INeighborStrategys.Represents a node in the pathfinding graph.
Utility class for common number operations.
A functional interface representing a supplier that accepts a parameter and returns a result.
A Path is a sequence of positions that represents a path through a 3D space.
A Pathfinder is a class that can find a path between two positions while following a given set of
rules.
Defines a set of configurable parameters that govern the behavior of the A* pathfinding
algorithm.
A factory interface for creating
Pathfinder instances.Interface for hooks that are called during the pathfinding process.
An interface for initializing
Pathfinder instances.The result of a pathfinding operation.
Context for the current step of the pathfinding process.
Immutable container for the three core positions in a pathfinding operation.
Represents a pathfinding operation that can be configured with callbacks for different outcomes.
Represents a position.
The state of a finished pathfinding process.
Deprecated.
Pathetic's future focus will rely heavily on finding paths, not modifying or
post-processing them.
Represents a 3D vector within a pathfinding context.
A highly optimized, array-backed binary min-heap for A* pathfinding.
Base interface for pathfinding processors.
A quaternary (4-ary) min-heap implementation optimized for pathfinding algorithms.
Utility class to pack 3D grid coordinates (Region Indices or Block Positions) into a single
primitive long.
Contract for data structures that can dynamically resize their internal storage.
Provides context for an entire pathfinding search operation.
Contract for heap implementations that use sift operations to maintain heap property.
The SpatialData class represents the data associated with a grid region.
A performance-optimized heuristic strategy using squared distance metrics.
A processor that validates whether a node (PathPosition) or the transition to it is permissible
during pathfinding.
Utility class for creating and combining
ValidationProcessor instances.