wip

.gitignore

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

Cargo.toml

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

deno.json

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

preview/bundle.js

@@ -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
+};

src/find_path_config.rs

@@ -0,0 +1,26 @@
+#[derive(Debug, Clone, Default)]
+pub struct FindPathConfig {
+    pub diagonal_cost_multiplier: f32,
+    pub orthogonal_cost_multiplier: f32,
+    pub max_jump_cost: f32,
+    pub max_iterations: u32,
+    pub jump_blocked_diagonals: bool,
+}
+
+impl FindPathConfig {
+    pub fn new(
+        diagonal_cost_multiplier: Option<f32>,
+        orthogonal_cost_multiplier: Option<f32>,
+        max_jump_cost: Option<f32>,
+        max_iterations: Option<u32>,
+        jump_blocked_diagonals: Option<bool>,
+    ) -> Self {
+        FindPathConfig {
+            diagonal_cost_multiplier: diagonal_cost_multiplier.unwrap_or(1.0),
+            orthogonal_cost_multiplier: orthogonal_cost_multiplier.unwrap_or(1.0),
+            max_jump_cost: max_jump_cost.unwrap_or(5.0),
+            max_iterations: max_iterations.unwrap_or(99999),
+            jump_blocked_diagonals: jump_blocked_diagonals.unwrap_or(false),
+        }
+    }
+}