wip

Author: pagoru

.gitignore

@@ -1,3 +1,4 @@
 .idea
 node_modules
 coverage
+target

Cargo.lock

@@ -0,0 +1,10 @@
+[package]
+name = "oh_pathfinding"
+version = "0.0.0"
+edition = "2024"
+
+[lib]
+path = "src/lib.rs"
+crate-type = ["cdylib"]
+
+[dependencies]

Cargo.toml

@@ -4,5 +4,8 @@
   "exports": "./mod.ts",
   "imports": {
     "std/": "https://deno.land/std@0.224.0/"
+  },
+  "tasks": {
+    "build:lib": "cargo build --release"
   }
 }

deno.json

@@ -1,8 +1,9 @@
 // src/utils/grid.utils.ts
 var makeSquare = (layout) => {
   const maxLength = Math.max(layout.length, ...layout.map((row) => row.length));
-  const squareLayout = Array.from({ length: maxLength }, () =>
-    Array(maxLength).fill(null),
+  const squareLayout = Array.from(
+    { length: maxLength },
+    () => Array(maxLength).fill(null)
   );
   for (let i = 0; i < layout.length; i++) {
     for (let j = 0; j < layout[i].length; j++) {
@@ -13,8 +14,9 @@ var makeSquare = (layout) => {
 };
 var transpose = (matrix) => {
   const maxCols = Math.max(...matrix.map((row) => row.length));
-  const transposed = Array.from({ length: maxCols }, () =>
-    Array(matrix.length).fill(null),
+  const transposed = Array.from(
+    { length: maxCols },
+    () => Array(matrix.length).fill(null)
   );
   for (let i = 0; i < matrix.length; i++) {
     for (let j = 0; j < matrix[i].length; j++) {
@@ -92,7 +94,7 @@ var findPath = (startPoint, endPoint, grid, config) => {
   const orthogonalCostMultiplier = config.orthogonalCostMultiplier ?? 1;
   const maxJumpCost = config.maxJumpCost ?? 5;
   const maxIterations = config.maxIterations ?? 99999;
-  const jumpDiagonals = config.jumpDiagonals ?? false;
+  const jumpBlockedDiagonals = config.jumpBlockedDiagonals ?? false;
   const index = (point) => {
     return point.y * grid.height + point.x;
   };
@@ -110,7 +112,7 @@ var findPath = (startPoint, endPoint, grid, config) => {
     while (true) {
       const target = {
         x: src.x + dirX * jumpDistance,
-        y: src.y + dirY * jumpDistance,
+        y: src.y + dirY * jumpDistance
       };
       if (!grid.isWalkable(target)) {
         break;
@@ -125,7 +127,7 @@ var findPath = (startPoint, endPoint, grid, config) => {
       if (totalCost < visited[targetIndex]) {
         visited[targetIndex] = totalCost;
         queue.push(
-          new PathNode(target, prevNode, totalCost, heuristic(target)),
+          new PathNode(target, prevNode, totalCost, heuristic(target))
         );
       }
       prevPoint = target;
@@ -137,24 +139,13 @@ var findPath = (startPoint, endPoint, grid, config) => {
   };
   const addDiagonal = (prevNode, src, srcCost, dirX, dirY) => {
     const target = { x: src.x + dirX, y: src.y + dirY };
-    const moveCost =
-      srcCost +
-      (getMoveCostAt(src, target) ?? NOT_REACHED_COST) * diagonalCostMultiplier;
+    const moveCost = srcCost + (getMoveCostAt(src, target) ?? NOT_REACHED_COST) * diagonalCostMultiplier;
     const targetHeight = grid.getHeightAt(target);
     const aux1 = { x: src.x, y: src.y + dirY };
     const aux2 = { x: src.x + dirX, y: src.y };
     const targetIndex = index(target);
-    const canJumpDiagonals =
-      jumpDiagonals ||
-      (grid.isWalkable(aux1) &&
-        grid.isWalkable(aux2) &&
-        targetHeight == grid.getHeightAt(aux1) &&
-        targetHeight == grid.getHeightAt(aux2));
-    if (
-      grid.isWalkable(target) &&
-      canJumpDiagonals &&
-      moveCost < visited[targetIndex]
-    ) {
+    const canJumpDiagonals = jumpBlockedDiagonals || grid.isWalkable(aux1) && grid.isWalkable(aux2) && targetHeight == grid.getHeightAt(aux1) && targetHeight == grid.getHeightAt(aux2);
+    if (grid.isWalkable(target) && canJumpDiagonals && moveCost < visited[targetIndex]) {
       visited[targetIndex] = moveCost;
       queue.push(new PathNode(target, prevNode, moveCost, heuristic(target)));
     }
@@ -253,24 +244,15 @@ var Grid = class _Grid {
     return new _Grid(
       this.width,
       this.height,
-      new Float32Array(this.heightMatrix),
+      new Float32Array(this.heightMatrix)
     );
   }
   inBounds(point) {
-    return (
-      point.x >= 0 &&
-      point.x < this.width &&
-      point.y >= 0 &&
-      point.y < this.height
-    );
+    return point.x >= 0 && point.x < this.width && point.y >= 0 && point.y < this.height;
   }
   isWalkable(point) {
     const heightAt = this.getHeightAt(point);
-    return (
-      this.inBounds(point) &&
-      heightAt !== null &&
-      heightAt !== NON_WALKABLE_HEIGHT
-    );
+    return this.inBounds(point) && heightAt !== null && heightAt !== NON_WALKABLE_HEIGHT;
   }
   walkMatrix(callback) {
     for (let y = 0; y < this.height; y++) {
@@ -291,15 +273,15 @@ var Grid = class _Grid {
     }
     return matrix;
   }
-  findPath(
-    startPoint,
-    endPoint,
-    config = {
-      maxJumpCost: 5,
-      travelCosts: void 0,
-    },
-  ) {
+  findPath(startPoint, endPoint, config = {
+    maxJumpCost: 5,
+    travelCosts: void 0
+  }) {
     return findPath(startPoint, endPoint, this, config);
   }
 };
-export { Grid, makeSquare, transpose };
+export {
+  Grid,
+  makeSquare,
+  transpose
+};

preview/bundle.js

@@ -0,0 +1 @@
+mod open_list;

src/lib.rs

@@ -0,0 +1,131 @@
+use std::cmp::Ordering;
+use std::fmt::Debug;
+
+#[derive(Debug)]
+pub struct ListNode<Value> {
+	pub value: Value,
+	pub next: Option<Box<ListNode<Value>>>
+}
+
+#[allow(dead_code)]
+impl<Value> ListNode<Value> {
+	fn new(value: Value, next: Option<Box<ListNode<Value>>>) -> Self {
+		ListNode { value, next }
+	}
+}
+
+pub trait Compare<Value>: Debug {
+	fn compare(&self, a: &Value, b: &Value) -> Ordering;
+}
+
+#[derive(Debug)]
+pub struct OpenList<Value> {
+	start: Option<Box<ListNode<Value>>>,
+	size: usize,
+	comparator: Box<dyn Compare<Value>>
+}
+#[allow(dead_code)]
+impl<Value> OpenList<Value> {
+	pub fn new(comparator: Box<dyn Compare<Value>>) -> Self {
+		OpenList {
+			start: None,
+			size: 0,
+			comparator,
+		}
+	}
+	pub fn push(&mut self, value: Value) {
+		if self.start.is_none() {
+			self.start = Some(Box::new(ListNode { value, next: None }));
+			self.size += 1;
+			return;
+		}
+
+		let start = self.start.take().unwrap();
+		if self.comparator.compare(&value, &start.value) == Ordering::Less {
+			self.start = Some(Box::new(ListNode {
+				value,
+				next: Some(start),
+			}));
+			self.size += 1;
+			return;
+		}
+
+		let mut current = Some(start);
+		let mut prev = &mut self.start;
+
+		while let Some(mut node) = current.take() {
+			if let Some(next_node) = &node.next {
+				if self.comparator.compare(&value, &next_node.value) != Ordering::Greater {
+					node.next = Some(Box::new(ListNode {
+						value,
+						next: node.next.take(),
+					}));
+					*prev = Some(node);
+					self.size += 1;
+					return;
+				}
+			}
+
+			current = node.next.take();
+			*prev = Some(node);
+			prev = &mut prev.as_mut().unwrap().next;
+		}
+
+		*prev = Some(Box::new(ListNode { value, next: None }));
+		self.size += 1;
+	}
+
+	pub fn pop (&mut self) -> Result<Value, String> {
+		match self.start.take() {
+			None => Err("popping from an empty list".to_string()),
+			Some(mut popped) => {
+				self.start = popped.next.take();
+				self.size -= 1;
+				Ok(popped.value)
+			}
+		}
+	}
+
+	pub fn length(&self) -> usize {
+		self.size
+	}
+
+	pub fn is_empty(&self) -> bool {
+		self.start.is_none()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[derive(Debug)]
+	struct IntComparator;
+
+	impl Compare<i32> for IntComparator {
+		fn compare(&self, a: &i32, b: &i32) -> Ordering {
+			a.cmp(b)
+		}
+	}
+
+	#[test]
+	fn test_open_list() {
+		let comparator = Box::new(IntComparator);
+		let mut list = OpenList::new(comparator);
+
+		assert!(list.is_empty());
+		assert_eq!(list.length(), 0);
+
+		list.push(3);
+		list.push(1);
+		list.push(4);
+
+		assert!(!list.is_empty());
+		assert_eq!(list.length(), 3);
+
+		assert_eq!(list.pop(), Ok(1));
+		assert_eq!(list.pop(), Ok(3));
+		assert_eq!(list.pop(), Ok(4));
+		assert!(list.pop().is_err());
+	}
+}