calculate cost for exit tiles

front/src/Phaser/Game/GameMap.ts

@@ -133,6 +133,18 @@ export class GameMap {
         return grid;
     }
 
+    public getWalkingCostGrid(): number[][] {
+        const grid: number[][] = [];
+        for (let y = 0; y < this.map.height; y += 1) {
+            const row: number[] = [];
+            for (let x = 0; x < this.map.width; x += 1) {
+                row.push(this.getWalkingCostAt(x, y));
+            }
+            grid.push(row);
+        }
+        return grid;
+    }
+
     public getTileDimensions(): { width: number; height: number } {
         return { width: this.map.tilewidth, height: this.map.tileheight };
     }
@@ -339,6 +351,32 @@ export class GameMap {
         return false;
     }
 
+    private getWalkingCostAt(x: number, y: number): number {
+        const bigCost = 100;
+        for (const layer of this.phaserLayers) {
+            if (!layer.visible) {
+                continue;
+            }
+            const tile = layer.getTileAt(x, y);
+            if (!tile) {
+                continue;
+            }
+            if (
+                tile &&
+                (tile.properties[GameMapProperties.EXIT_URL] || tile.properties[GameMapProperties.EXIT_SCENE_URL])
+            ) {
+                return bigCost;
+            }
+            for (const property of layer.layer.properties) {
+                //@ts-ignore
+                if (property.name && property.name === "exitUrl") {
+                    return bigCost;
+                }
+            }
+        }
+        return 0;
+    }
+
     private triggerAllProperties(): void {
         const newProps = this.getProperties(this.key ?? 0);
         const oldProps = this.lastProperties;

front/src/Phaser/Game/GameScene.ts

@@ -570,6 +570,7 @@ export class GameScene extends DirtyScene {
         this.pathfindingManager = new PathfindingManager(
             this,
             this.gameMap.getCollisionGrid(),
+            this.gameMap.getWalkingCostGrid(),
             this.gameMap.getTileDimensions()
         );
 
@@ -583,12 +584,6 @@ export class GameScene extends DirtyScene {
             waScaleManager
         );
 
-        this.pathfindingManager = new PathfindingManager(
-            this,
-            this.gameMap.getCollisionGrid(),
-            this.gameMap.getTileDimensions()
-        );
-
         this.activatablesManager = new ActivatablesManager(this.CurrentPlayer);
 
         biggestAvailableAreaStore.recompute();
@@ -1530,7 +1525,7 @@ ${escapedMessage}
                 phaserLayers[i].setCollisionByProperty({ collides: true }, visible);
             }
         }
-        this.pathfindingManager.setCollisionGrid(this.gameMap.getCollisionGrid());
+        this.pathfindingManager.setCollisionGrid(this.gameMap.getCollisionGrid(), this.gameMap.getWalkingCostGrid());
         this.markDirty();
     }
 

front/src/Utils/PathfindingManager.ts

@@ -8,19 +8,26 @@ export class PathfindingManager {
     private grid: number[][];
     private tileDimensions: { width: number; height: number };
 
-    constructor(scene: Phaser.Scene, collisionsGrid: number[][], tileDimensions: { width: number; height: number }) {
+    constructor(
+        scene: Phaser.Scene,
+        collisionsGrid: number[][],
+        walkingCostGrid: number[][],
+        tileDimensions: { width: number; height: number }
+    ) {
         this.scene = scene;
 
         this.easyStar = new EasyStar.js();
-        this.easyStar.enableDiagonals();
+        // this.easyStar.enableDiagonals();
 
         this.grid = collisionsGrid;
         this.tileDimensions = tileDimensions;
         this.setEasyStarGrid(collisionsGrid);
+        this.setWalkingCostGrid(walkingCostGrid);
     }
 
-    public setCollisionGrid(collisionGrid: number[][]): void {
+    public setCollisionGrid(collisionGrid: number[][], walkingCostGrid: number[][]): void {
         this.setEasyStarGrid(collisionGrid);
+        this.setWalkingCostGrid(walkingCostGrid);
     }
 
     public async findPath(
@@ -115,6 +122,14 @@ export class PathfindingManager {
         this.easyStar.setAcceptableTiles([0]); // zeroes are walkable
     }
 
+    private setWalkingCostGrid(grid: number[][]): void {
+        for (let y = 0; y < grid.length; y += 1) {
+            for (let x = 0; x < grid[y].length; x += 1) {
+                this.easyStar.setAdditionalPointCost(x, y, grid[y][x]);
+            }
+        }
+    }
+
     private logGridToTheConsole(grid: number[][]): void {
         let rowNumber = 0;
         for (const row of grid) {