commit changes

Author: digitsensitive

.github/workflows/learn-github-actions.yml

@@ -0,0 +1,19 @@
+name: Publish Package to npmjs
+run-name: ${{ github.actor }} published a new Package to npmjs
+on:
+  release:
+    types: [published]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      # Setup .npmrc file to publish to npm
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '16.x'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/publish-package-to-npmjs.yml

@@ -14,13 +14,18 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ---
 
-## [1.X.X] - 2023-XX-XX
+## [1.2.7] - 2023-04-26
+
+### Added
+
+- Implement `Get as close as possible` option when the path is blocked ([Issue #10, @sefabaser](https://github.com/digitsensitive/astar-typescript/issues/10))
 
 ### Changed
 
 - Update most dependencies in `./` and `./example`
-- Update Copyright to 2013 in different locations
-- Small optimizations in `grid.ts`
+- Update Copyright to 2023 in different locations
+- Small optimizations in `grid.ts` and `util.ts`
+- Add `CopyPlugin` and `HtmlWebpackPlugin` to webpack
 
 ---
 

CHANGELOG.md

@@ -131,6 +131,8 @@ let myPathway = this.aStarInstance.findPath(startPos, goalPos);
 
 Additional parameters may be passed to adapt your finder.
 
+### Diagonal movements
+
 If you want to disable `diagonal movements`:
 
 ```ts
@@ -143,6 +145,8 @@ this.aStarInstance = new AStarFinder({
 });
 ```
 
+### Heuristic function
+
 Set the `heuristic function` (Manhattan, Euclidean, Chebyshev or Octile):
 
 ```ts
@@ -172,6 +176,8 @@ this.aStarInstance = new AStarFinder({
 });
 ```
 
+### Start and End Node
+
 Include or Exclude the `start and end node`:
 
 ```ts
@@ -185,6 +191,18 @@ this.aStarInstance = new AStarFinder({
 });
 ```
 
+### Allow path as close as possible
+
+```ts
+this.aStarInstance = new AStarFinder({
+  grid: {
+    width: 8,
+    height: 8
+  },
+  allowPathAsCloseAsPossible: true
+});
+```
+
 ## Prettier
 
 This library uses [Prettier](https://github.com/prettier/prettier).

README.md

@@ -5,7 +5,7 @@
  * @license {@link https://opensource.org/licenses/MIT|MIT License}
  */
 
-import { AStarFinder } from '../../../lib/astar';
+import { AStarFinder } from '../../../dist/astar';
 import { DatGuiService } from '../services/dat-gui.service';
 import { GameObject } from '../objects/gameobject';
 

example/src/scenes/main-scene.ts

@@ -123,8 +123,7 @@ export class Grid {
 
   /**
    * Get surrounding nodes.
-   * @param currentXPos [x-position on the grid]
-   * @param currentYPos [y-position on the grid]
+   * @param currentPosition [IPoint on the grid]
    * @param diagnonalMovementAllowed [is diagnonal movement allowed?]
    */
   public getSurroundingNodes(
@@ -140,20 +139,24 @@ export class Grid {
 
     for (let y = minY; y <= maxY; y++) {
       for (let x = minX; x <= maxX; x++) {
-        if (this.isOnTheGrid({ x, y })) {
-          if (this.isWalkableAt({ x, y })) {
-            if (diagnonalMovementAllowed) {
-              surroundingNodes.push(this.getNodeAt({ x, y }));
-            } else {
-              if (x == currentPosition.x || y == currentPosition.y) {
-                surroundingNodes.push(this.getNodeAt({ x, y }));
-              }
+        // Evaluate if NOT current position
+        if (x !== currentPosition.x || y !== currentPosition.y) {
+          // Evaluate if current position is on the grid AND walkable
+          if (
+            this.isOnTheGrid({ x: x, y: y }) &&
+            this.isWalkableAt({ x: x, y: y })
+          ) {
+            // Add node
+            // if diagonal movement is allowed OR
+            // if the node lies on the cross through the center node
+            if (
+              diagnonalMovementAllowed ||
+              x == currentPosition.x ||
+              y == currentPosition.y
+            ) {
+              surroundingNodes.push(this.getNodeAt({ x: x, y: y }));
             }
-          } else {
-            continue;
           }
-        } else {
-          continue;
         }
       }
     }
@@ -190,21 +193,22 @@ export class Grid {
    * Get a clone of the grid
    */
   public clone(): Node[][] {
-    const cloneGrid: Node[][] = [];
-    let id: number = 0;
+    const clonedGrid: Node[][] = [];
+    let nodeId: number = 0;
 
     for (let y = 0; y < this.height; y++) {
-      cloneGrid[y] = [];
+      clonedGrid[y] = [];
       for (let x = 0; x < this.width; x++) {
-        cloneGrid[y][x] = new Node({
-          id: id,
+        clonedGrid[y][x] = new Node({
+          id: nodeId,
           position: { x: x, y: y },
           walkable: this.gridNodes[y][x].getIsWalkable()
         });
 
-        id++;
+        nodeId++;
       }
     }
-    return cloneGrid;
+
+    return clonedGrid;
   }
 }

lib/core/grid.ts

@@ -8,6 +8,7 @@
  * https://github.com/riscy/a_star_on_grids#heuristics
  */
 
+import { IPoint } from '../interfaces/astar.interfaces';
 import { Heuristic } from '../types/astar.types';
 
 /**
@@ -19,9 +20,9 @@ import { Heuristic } from '../types/astar.types';
  */
 export function calculateHeuristic(
   heuristicFunction: Heuristic,
-  pos0,
-  pos1,
-  weight
+  pos0: IPoint,
+  pos1: IPoint,
+  weight: number
 ): number {
   const dx = Math.abs(pos1.x - pos0.x);
   const dy = Math.abs(pos1.y - pos0.y);

lib/core/heuristic.ts

@@ -13,13 +13,8 @@ export function backtrace(
   // Init empty path
   const path: number[][] = [];
 
-  let currentNode: Node;
-  if (includeEndNode) {
-    // Attach the end node to be the current node
-    currentNode = node;
-  } else {
-    currentNode = node.getParent();
-  }
+  // If `includeEndNode` is enabled, attach the end node to be the current node
+  let currentNode: Node = includeEndNode ? node : node.getParent();
 
   // Loop as long the current node has a parent
   while (currentNode.getParent()) {

lib/core/util.ts

@@ -19,6 +19,7 @@ export class AStarFinder {
   private openList: Node[];
 
   // Pathway variables
+  private allowPathAsCloseAsPossible: boolean;
   readonly diagonalAllowed: boolean;
   private heuristic: Heuristic;
   readonly includeStartNode: boolean;
@@ -53,6 +54,10 @@ export class AStarFinder {
     this.includeEndNode =
       aParams.includeEndNode !== undefined ? aParams.includeEndNode : true;
 
+    // Default path as close as possible not allowed
+    this.allowPathAsCloseAsPossible =
+      aParams.allowPathAsCloseAsPossible || false;
+
     // Set weight
     this.weight = aParams.weight || 1;
   }
@@ -170,7 +175,19 @@ export class AStarFinder {
         }
       }
     }
-    // Path could not be created
+
+    // At this point the path to the end position could NOT be created
+
+    // Return path as close as possible if enabled
+    if (this.allowPathAsCloseAsPossible) {
+      return backtrace(
+        this.closedList[this.closedList.length - 1],
+        this.includeStartNode,
+        false
+      );
+    }
+
+    // Return empty path, because could NOT be created
     return [];
   }
 

lib/finders/astar-finder.ts

@@ -7,6 +7,7 @@ export interface IAStarFinderConstructor {
   weight?: number;
   includeStartNode?: boolean;
   includeEndNode?: boolean;
+  allowPathAsCloseAsPossible?: boolean;
 }
 
 export interface IGridConstructor {