Crate torchbearer

source ·
Expand description

Docs Crates.io Crates.io

A set of tools to find your path in a grid based dungeon. Field of view, pathfinding…

Inspired by tcod-rs and bracket-pathfinding, it aims to be simpler to use than tcod, without requiring a sdl2 dependency, and faster than bracket-pathfinding.

Get started

Implement the VisionMap trait to use the field of vision algorithms, or the PathMap trait to use the pathfinding algorithms.

use torchbearer::Point;
use torchbearer::fov::{field_of_view, VisionMap};
use torchbearer::path::{astar_path_fourwaygrid, PathMap};

struct SampleMap {
    width: i32,
    height: i32,
    transparent: Vec<bool>,
    walkable: Vec<bool>,
}

impl SampleMap {
    fn new(width: i32, height: i32) -> Self {
         // (…)
   }
}

impl VisionMap for SampleMap {
    fn dimensions(&self) -> (i32, i32) {
        (self.width, self.height)
    }

    fn is_transparent(&self, (x, y): Point) -> bool {
        self.transparent[(x + y * self.width) as usize]
    }
}

impl PathMap for SampleMap {
    fn dimensions(&self) -> (i32, i32) {
        (self.width, self.height)
    }

    fn is_walkable(&self, (x, y): Point) -> bool {
        self.walkable[(x + y * self.width) as usize]
    }
}

let sample_map = SampleMap::new(16, 10);

// (…) You probably want at this point to add some walls to your map.

let from = (1,1);
let to = (3,8);
let radius = 5;

for visible_position in field_of_view(&sample_map, from, radius) {
    // (…)
}

if let Some(path) = astar_path_fourwaygrid(&sample_map, from, to) {
    // (…)
}

Even though torchbearer provides by default a pathfinding simple function for fourway grid maps (meaning, you can go north, south, east and west), you can also implement your own graph, to support other types of movements (8 ways, north, ne, east, se, south, sw, west, nw), or teleportation, or… You can also simply decide you want to tweak your heuristics, so that moving along roads is easier than climbing a mountain for instance.

use torchbearer::path::{astar_path, Graph, NodeId};

struct MyMap {}

impl Graph for MyMap {
    // (..)
}

let my_map = MyMap {};

let from = (1) as NodeId;
let to = (2) as NodeId;

if let Some(path) = astar_path(&my_map, to, from) {
    // (…)
}

Modules

Collection of bresenham implementation of lines, circles, … as Iterable.
Collection of utility function to calculate field of vision.
Collection of utility functions to find path.

Type Definitions

A convenience type alias for a position tuple.