README
T
Edge
- ::add_edgeGraph::add_edge
- ::add_nodeGraph::add_node
- ::add_undirected_edgeGraph::add_undirected_edge
- ::astarGraph::astar
- ::bfsGraph::bfs
- ::dijkstraGraph::dijkstra
- ::has_pathGraph::has_path
- ::in_boundsGraph::in_bounds
- ::neighborsGraph::neighbors
- ::newGraph::new
- ::node_countGraph::node_count
- ::reachable_countGraph::reachable_count
- ::astarGrid::astar
- ::bfsGrid::bfs
- ::bidirectional_bfsGrid::bidirectional_bfs
- ::cost_atGrid::cost_at
- ::dijkstraGrid::dijkstra
- ::indexGrid::index
- ::insideGrid::inside
- ::is_blockedGrid::is_blocked
- ::newGrid::new
- ::pointGrid::point
- ::set_blockedGrid::set_blocked
- ::set_costGrid::set_cost
- ::to_graphGrid::to_graph
- ::firstPathReport::first
- ::is_emptyPathReport::is_empty
- ::lastPathReport::last
- ::lengthPathReport::length
- ::not_foundPathReport::not_found
- ::singlePathReport::single
- ::successPathReport::success
T
Point
- ::is_emptyPriorityQueue::is_empty
- ::lengthPriorityQueue::length
- ::newPriorityQueue::new
- ::popPriorityQueue::pop
- ::pushPriorityQueue::push
T
QueueItem

pathforge

A MoonBit graph search and grid pathfinding toolkit with BFS, Dijkstra and A*.

pathfinding

graph

astar

dijkstra

bfs

Download zip

Author

Deviaana

Version

0.1.0

License

MIT

Repository

github.com/Deviaana/GitLink_ana.git

Last updated

3 months ago

Downloads

No dependencies

#PathForge

PathForge is a lightweight MoonBit graph search and grid pathfinding toolkit. It packages reusable data structures and algorithms for route planning, game AI, algorithm teaching, and WebAssembly demos.

#Features

Directed weighted graph based on adjacency lists
BFS for shortest paths by hop count
Dijkstra for minimum-cost paths with non-negative edge costs
A* with custom heuristics and node reopening for admissible inconsistent heuristics
Grid adapter with blocked cells and terrain movement costs
Unified PathReport result type with found status, cost, visited count, and path data
Unit tests, coverage-ready CI, and a command-line demo

#Project Layout

.
|-- graph.mbt              # Graph, BFS, Dijkstra, A*
|-- grid.mbt               # Grid pathfinding adapter
|-- priority_queue.mbt     # Min-priority queue
|-- path_report.mbt        # Search result type
|-- pathforge_test.mbt     # Unit tests
|-- cmd/main/main.mbt      # Demo entry point
|-- docs/api.md            # Public API reference
|-- docs/application.md    # Project application notes
|-- moon.mod               # MoonBit module metadata
`-- moon.pkg               # Root package config

#Quick Start

Install MoonBit, then run:

moon check
moon test
moon run cmd/main

Expected demo output:

PathForge demo
found: true
cost: 15
visited: 29
path length: 16

#Example

let grid = @pathforge.Grid::new(8, 5)
grid.set_blocked(@pathforge.Point::{ x: 2, y: 0 }, true)
grid.set_blocked(@pathforge.Point::{ x: 2, y: 1 }, true)

let result = grid.astar(
  @pathforge.Point::{ x: 0, y: 0 },
  @pathforge.Point::{ x: 7, y: 4 },
)
println("found: \{result.found}")
println("cost: \{result.cost}")

#API Documentation

See docs/api.md for the public API reference.

#Publishing

The module metadata in moon.mod includes mooncakes.io fields: license, keywords, repository, description, and homepage.

Before publishing:

moon check --deny-warn
moon test
moon coverage analyze -- -f summary
moon package
moon publish

#License

MIT. See LICENSE.

Edge

source

pub(all) struct Edge {
  to : Int
  cost : Int
}

Graph

source

pub(all) struct Graph {
  adj : Array[Array[Edge]]
}

Graph::add_edge

source

fn Graph::add_edge(self : Graph, from : Int, to : Int, cost : Int) -> Unit

Graph::add_node

source

fn Graph::add_node(self : Graph) -> Int

Graph::add_undirected_edge

source

fn Graph::add_undirected_edge(self : Graph, a : Int, b : Int, cost : Int) -> Unit

Graph::astar

source

fn Graph::astar(self : Graph, start : Int, goal : Int, heuristic : (Int, Int) -> Int) -> PathReport

Graph::bfs

source

fn Graph::bfs(self : Graph, start : Int, goal : Int) -> PathReport

Graph::dijkstra

source

fn Graph::dijkstra(self : Graph, start : Int, goal : Int) -> PathReport

Graph::has_path

source

fn Graph::has_path(self : Graph, start : Int, goal : Int) -> Bool

Graph::in_bounds

source

fn Graph::in_bounds(self : Graph, node : Int) -> Bool

Graph::neighbors

source

fn Graph::neighbors(self : Graph, node : Int) -> Array[Edge]

Graph::new

source

fn Graph::new(size : Int) -> Graph

Graph::node_count

source

fn Graph::node_count(self : Graph) -> Int

Graph::reachable_count

source

fn Graph::reachable_count(self : Graph, start : Int) -> Int

Grid

source

pub(all) struct Grid {
  width : Int
  height : Int
  blocked : Array[Bool]
  weights : Array[Int]
}

Grid::astar

source

fn Grid::astar(self : Grid, start : Point, goal : Point) -> PathReport

Grid::bfs

source

fn Grid::bfs(self : Grid, start : Point, goal : Point) -> PathReport

Grid::bidirectional_bfs

source

fn Grid::bidirectional_bfs(self : Grid, start : Point, goal : Point) -> PathReport

Grid::cost_at

source

fn Grid::cost_at(self : Grid, p : Point) -> Int

Grid::dijkstra

source

fn Grid::dijkstra(self : Grid, start : Point, goal : Point) -> PathReport

Grid::index

source

fn Grid::index(self : Grid, p : Point) -> Int

Grid::inside

source

fn Grid::inside(self : Grid, p : Point) -> Bool

Grid::is_blocked

source

fn Grid::is_blocked(self : Grid, p : Point) -> Bool

Grid::new

source

fn Grid::new(width : Int, height : Int) -> Grid

Grid::point

source

fn Grid::point(self : Grid, index : Int) -> Point

Grid::set_blocked

source

fn Grid::set_blocked(self : Grid, p : Point, value : Bool) -> Unit

Grid::set_cost

source

fn Grid::set_cost(self : Grid, p : Point, cost : Int) -> Unit

Grid::to_graph

source

fn Grid::to_graph(self : Grid) -> Graph

PathReport

source

pub(all) struct PathReport {
  found : Bool
  cost : Int
  visited : Int
  path : Array[Int]
}

PathReport::first

source

fn PathReport::first(self : PathReport) -> Int?

PathReport::is_empty

source

fn PathReport::is_empty(self : PathReport) -> Bool

PathReport::last

source

fn PathReport::last(self : PathReport) -> Int?

PathReport::length

source

fn PathReport::length(self : PathReport) -> Int

PathReport::not_found

source

fn PathReport::not_found(visited : Int) -> PathReport

PathReport::single

source

fn PathReport::single(node : Int) -> PathReport

PathReport::success

source

fn PathReport::success(cost : Int, visited : Int, path : Array[Int]) -> PathReport

Point

source

pub(all) struct Point {
  x : Int
  y : Int
}

PriorityQueue

source

pub(all) struct PriorityQueue {
  data : Array[QueueItem]
}

PriorityQueue::is_empty

source

fn PriorityQueue::is_empty(self : PriorityQueue) -> Bool

PriorityQueue::length

source

fn PriorityQueue::length(self : PriorityQueue) -> Int

PriorityQueue::new

source

fn PriorityQueue::new() -> PriorityQueue

PriorityQueue::pop

source

fn PriorityQueue::pop(self : PriorityQueue) -> QueueItem?

PriorityQueue::push

source

fn PriorityQueue::push(self : PriorityQueue, node : Int, priority : Int) -> Unit

QueueItem

source

pub(all) struct QueueItem {
  node : Int
  priority : Int
}

Source Files

Install

Download zip

A MoonBit graph search and grid pathfinding toolkit with BFS, Dijkstra and A*.

pathfindinggraphastardijkstrabfs

Deviaana

MIT

github.com/Deviaana/GitLink_ana.git

Updated 3 months ago

35 downloads

Site source Report issue Modules Skills CLI Build queue Statistics

pathforge

#PathForge

#Features

#Project Layout

#Quick Start

#Example

#API Documentation

#Publishing

#License

#Edge

#Graph

#Graph::add_edge

#Graph::add_node

#Graph::add_undirected_edge

#Graph::astar

#Graph::bfs

#Graph::dijkstra

#Graph::has_path

#Graph::in_bounds

#Graph::neighbors

#Graph::new

#Graph::node_count

#Graph::reachable_count

#Grid

#Grid::astar

#Grid::bfs

#Grid::bidirectional_bfs

#Grid::cost_at

#Grid::dijkstra

#Grid::index

#Grid::inside

#Grid::is_blocked

#Grid::new

#Grid::point

#Grid::set_blocked

#Grid::set_cost

#Grid::to_graph

#PathReport

#PathReport::first

#PathReport::is_empty

#PathReport::last

#PathReport::length

#PathReport::not_found

#PathReport::single

#PathReport::success

#Point

#PriorityQueue

#PriorityQueue::is_empty

#PriorityQueue::length

#PriorityQueue::new

#PriorityQueue::pop

#PriorityQueue::push

#QueueItem

Source Files

Edge

Graph

Graph::add_edge

Graph::add_node

Graph::add_undirected_edge

Graph::astar

Graph::bfs

Graph::dijkstra

Graph::has_path

Graph::in_bounds

Graph::neighbors

Graph::new

Graph::node_count

Graph::reachable_count

Grid

Grid::astar

Grid::bfs

Grid::bidirectional_bfs

Grid::cost_at

Grid::dijkstra

Grid::index

Grid::inside

Grid::is_blocked

Grid::new

Grid::point

Grid::set_blocked

Grid::set_cost

Grid::to_graph

PathReport

PathReport::first

PathReport::is_empty

PathReport::last

PathReport::length

PathReport::not_found

PathReport::single

PathReport::success

Point

PriorityQueue

PriorityQueue::is_empty

PriorityQueue::length

PriorityQueue::new

PriorityQueue::pop

PriorityQueue::push

QueueItem