Struct controlled_astar::node::Node

pub struct Node {
    pub x: usize,
    pub y: usize,
    pub is_blocked: bool,
    pub neighbors: BTreeMap<Direction, Option<(usize, usize)>>,
}

Represents a node on a map.

Fields

x: usize

y: usize

is_blocked: bool

neighbors: BTreeMap<Direction, Option<(usize, usize)>>

Implementations

impl Node

pub fn new( x: usize, y: usize, is_blocked: bool, max_x: usize, max_y: usize ) -> Self

Creates a new Node and initializes neighbors for the four basic directions.

Parameters

• x: The x-coordinate of the node.
• y: The y-coordinate of the node.
• is_blocked: Indicates whether the node is blocked.
• max_x: The maximum x dimension of the map.
• max_y: The maximum y dimension of the map.

Returns

A newly created Node instance.

Examples

use my_crate::Node;

// Create a new `Node` at position (2, 3) which is not blocked
let node = Node::new(2, 3, false, 10, 10);

// Check the node's coordinates and blocked status
assert_eq!(node.x, 2);
assert_eq!(node.y, 3);
assert_eq!(node.is_blocked, false);

pub fn set_neighbor( &mut self, direction: Direction, neighbor_pos: Option<(usize, usize)> )

Sets the neighbor position for a specific direction.

Parameters

• direction: The direction for which to set the neighbor.
• neighbor_pos: The position of the neighbor.

Example

let mut node = Node::new(0, 0, false, 10, 10);
node.set_neighbor(Direction::North, Some((0, 1)));

pub fn remove_neighbor(&mut self, direction: Direction)

Removes the neighbor for a specific direction.

Parameters

• direction: The direction for which to remove the neighbor.

Example

let mut node = Node::new(0, 0, false, 10, 10);
node.remove_neighbor(Direction::North);

pub fn set_blocked(&mut self, blocked: bool)

Sets whether the node is blocked or not.

Parameters

• blocked: The blocked status.

Example

let mut node = Node::new(0, 0, false, 10, 10);
node.set_blocked(true);

pub fn get_directions(&self) -> Vec<Direction>

Returns a vector of directions where neighbors are present.

Returns

A vector containing the directions of neighbors.

Example

let node = Node::new(0, 0, false, 10, 10);
let directions = node.get_directions();

pub fn grid_to_nodes(grid: &[Vec<i32>]) -> HashMap<(usize, usize), Node>

Converts a 2D grid into Node objects.

Parameters

• grid: The 2D grid where 1 represents a blocked node and 0 represents a free node.

Returns

A HashMap containing Node objects mapped by their positions.

Example

let grid = vec![
    vec![0, 1, 0],
    vec![0, 0, 1],
];
let nodes = Node::grid_to_nodes(&grid);

pub fn print_grid(grid: &[Vec<i32>], path: &Option<Vec<(usize, usize)>>)

Prints a 2D grid and an optional path to the screen.

Parameters

• grid: The 2D grid.
• path: An optional vector representing the path to be printed on the grid.

Example

let grid = vec![
    vec![0, 0, 0],
    vec![0, 1, 0],
];
let path = Some(vec![(0, 0), (1, 1)]);
Node::print_grid(&grid, &path);

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl Hash for Node

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Node

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

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

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

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

impl Eq for Node

impl StructuralPartialEq for Node