Struct ComputedGrid

pub struct ComputedGrid {
    grid: Grid,
    standard_grid: Option<StandardGrid>,
    walkable_nodes: Vec<Point2<i8>>,
    coords_to_node: HashMap<Point2<i8>, usize>,
    valid_actions: Vec<[bool; 5]>,
    distance_matrix: Vec<Vec<Option<u8>>>,
    walls: Vec<Wall>,
}

A Grid with precomputed data for faster pathfinding.

This struct is created by ComputedGrid::try_from.

Examples

use core_pb::grid::standard_grid::StandardGrid;

let grid = StandardGrid::Blank.compute_grid();

Fields

grid: Grid

standard_grid: Option<StandardGrid>

walkable_nodes: Vec<Point2<i8>>

coords_to_node: HashMap<Point2<i8>, usize>

valid_actions: Vec<[bool; 5]>

walkable, right, left, up, down

distance_matrix: Vec<Vec<Option<u8>>>

note that all walkable nodes might not be reachable from each other

walls: Vec<Wall>

walls represent rectangles with top left corner at the specified point

Implementations

impl ComputedGrid

pub fn grid(&self) -> &Grid

Returns the underlying Grid.

Examples

use core_pb::grid::standard_grid::StandardGrid;

let grid = StandardGrid::Blank.compute_grid();

assert_eq!(grid.grid()[0][0], true);

pub fn standard_grid(&self) -> &Option<StandardGrid>

Returns the underlying StandardGrid, if one was used to construct it.

pub fn walkable_nodes(&self) -> &Vec<Point2<i8>>

Returns the positions of all walkable nodes in the grid.

Examples

use nalgebra::Point2;
use core_pb::grid::standard_grid::StandardGrid;

let grid = StandardGrid::Blank.compute_grid();
assert_eq!(grid.walkable_nodes()[0], Point2::new(1, 1));

pub fn coords_to_node(&self, p: &Point2<i8>) -> Option<usize>

Returns the index of the given position in the walkable_nodes vector, or None if the position is not walkable.

Examples

use nalgebra::Point2;
use core_pb::grid::standard_grid::StandardGrid;

let grid = StandardGrid::Blank.compute_grid();
assert_eq!(grid.coords_to_node(&Point2::new(1, 1)), Some(0));
assert_eq!(grid.coords_to_node(&Point2::new(0, 0)), None);

pub fn valid_actions(&self, p: Point2<i8>) -> Option<[bool; 5]>

Returns the valid actions for the given position.

The five values represent:

• whether the node is walkable
• whether the node to the right is walkable
• whether the node to the left is walkable
• whether the node above is walkable
• whether the node below is walkable

Examples

use nalgebra::Point2;
use core_pb::grid::standard_grid::StandardGrid;

let grid = StandardGrid::Blank.compute_grid();
assert_eq!(grid.valid_actions(Point2::new(1, 1)), Some([true, false, false, false, false]));

pub fn wall_at(&self, p: &Point2<i8>) -> bool

Returns whether there is a wall at a given position

Examples

use nalgebra::Point2;
use core_pb::grid::standard_grid::StandardGrid;

let grid = StandardGrid::Blank.compute_grid();
assert_eq!(grid.wall_at(&Point2::new(0, 0)), true);
assert_eq!(grid.wall_at(&Point2::new(1, 1)), false);
assert_eq!(grid.wall_at(&Point2::new(32, 32)), true);

pub fn dist(&self, p1: &Point2<i8>, p2: &Point2<i8>) -> Option<u8>

Returns the distance between two points, or None if the points are not both walkable.

Examples

use nalgebra::Point2;
use core_pb::grid::standard_grid::StandardGrid;

let grid = StandardGrid::Pacman.compute_grid();
assert_eq!(grid.dist(&Point2::new(1, 1), &Point2::new(1, 1)), Some(0));
assert_eq!(grid.dist(&Point2::new(1, 1), &Point2::new(1, 2)), Some(1));

pub fn neighbors(&self, p: &Point2<i8>) -> Vec<Point2<i8>>

Returns all the walkable neighbors of the given position.

Examples

use nalgebra::Point2;
use core_pb::grid::standard_grid::StandardGrid;

let grid = StandardGrid::Pacman.compute_grid();
assert!(grid.neighbors(&Point2::new(1, 1)).contains(&Point2::new(1, 2)));
assert!(grid.neighbors(&Point2::new(1, 1)).contains(&Point2::new(2, 1)));

pub fn walls(&self) -> &Vec<Wall>

Returns the Walls in the grid.

Examples

use core_pb::grid::standard_grid::StandardGrid;

let grid = StandardGrid::Pacman.compute_grid();
let walls = grid.walls();

pub fn node_nearest(&self, x: f32, y: f32) -> Option<Point2<i8>>

Return the walkable node from the nodes surrounding this point

pub fn bfs_path( &self, start: Point2<i8>, finish: Point2<i8>, ) -> Option<Vec<Point2<i8>>>

Returns the shortest path, if one exists, from start to finish The path includes path the start and the finish

fn compute_open_grid() -> Self

Trait Implementations

impl Clone for ComputedGrid

fn clone(&self) -> ComputedGrid

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ComputedGrid

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

Formats the value using the given formatter.

impl Default for ComputedGrid

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ComputedGrid

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<StandardGrid> for ComputedGrid

fn from(value: StandardGrid) -> Self

Converts to this type from the input type.

impl PartialEq for ComputedGrid

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ComputedGrid

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<[[bool; 32]; 32]> for ComputedGrid

type Error = String

The type returned in the event of a conversion error.

fn try_from(grid: Grid) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for ComputedGrid