🥮 mooncakes.io

pathforge

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

pathfinding
graph
astar
dijkstra
bfs
moon add Deviaana/pathforge@0.1.0
Download zip
Author
Version
0.1.0
License
MIT
Repository
Last updated
28 days ago
Downloads
2
README

#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

#
PriorityQueue::pop

source

#
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

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io