Struct hierarchical_pathfinding::prelude::PathCacheConfig

pub struct PathCacheConfig {
    pub chunk_size: usize,
    pub cache_paths: bool,
    pub a_star_fallback: bool,
    pub perfect_paths: bool,
}

Options for configuring the PathCache

Default options:

assert_eq!(
    PathCacheConfig {
        chunk_size: 8,
        cache_paths: true,
        a_star_fallback: true,
        perfect_paths: false,
    },
    Default::default()
);

Fields

chunk_size: usize

The size of the individual Chunks (defaults to 8)

tl;dr: Depends highly on the size of your Grid and Lengths of your Paths; requires Experimentation if you care.

Rough guide: Scale with a bigger Grid and longer desired Paths. (don’t quote me on this)

This has many different effects on the Performance and Memory:

smaller chunks make calculations within a Chunk faster

• => decreased update time in tiles_changed
• => decreased time to find start and end Nodes

bigger chunks lead to fewer Chunks and Nodes

• => decreased time of actual search (especially for unreachable goals)
• => longer Paths can be found a lot faster

Use Case	Recommendation
Frequent Updates	Smaller Chunks
Longer Paths required	Larger Chunks
Larger Grid	Larger Chunks
“No Path found” is common	Larger Chunks
Grid consists of small, windy corridors	Smaller Chunks

cache_paths: bool

true (default): store the Paths inside each Chunk.

false: only store the Cost of the Path.

If set to false, calculating the full Path between two Points takes significantly more time. See AbstractPath for more details.

a_star_fallback: bool

true (default): When a Path is short (roughly Length < 2 * chunk_size), a regular A* search is performed on the Grid after HPA* calculated a Path to confirm the existence and length.

false: The Paths are left as they are.

Setting this option to false will improve performance a bit, but the Paths will take seemingly random detours that makes them longer than they should be.

perfect_paths: bool

true: Nodes are placed on every open entrance of a Chunk. This means that the resulting Paths are always the most optimal ones, but both Memory Usage and Performance are worse.

false (default): Nodes are placed on only some chunk entrances.

The exact effect depends greatly on the Grid and how the Chunks and their entrances align.

Implementations

impl PathCacheConfig

pub const LOW_MEM: PathCacheConfig

an example PathCacheConfig with options set to reduce Memory Usage

Values:

assert_eq!(
    PathCacheConfig {
        chunk_size: 32,
        cache_paths: false,
        a_star_fallback: true,
        perfect_paths: false,
    },
    PathCacheConfig::LOW_MEM
);

pub const HIGH_PERFORMANCE: PathCacheConfig

an example PathCacheConfig with options set to improve Performance

Values:

assert_eq!(
    PathCacheConfig {
        chunk_size: 8,
        cache_paths: true,
        a_star_fallback: false,
        perfect_paths: false,
    },
    PathCacheConfig::HIGH_PERFORMANCE
);

Trait Implementations

impl Clone for PathCacheConfig

fn clone(&self) -> PathCacheConfig

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PathCacheConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PathCacheConfig

fn default() -> PathCacheConfig

Returns the “default value” for a type.

impl PartialEq<PathCacheConfig> for PathCacheConfig

fn eq(&self, other: &PathCacheConfig) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &PathCacheConfig) -> bool

This method tests for !=.

impl Copy for PathCacheConfig

impl StructuralPartialEq for PathCacheConfig