Move passability rules to World class

src/fheroes2/heroes/route.h

@@ -115,8 +115,6 @@ namespace Route
         bool hide;
     };
 
-    bool PassableFromToTile( s32 from, s32 to, int direct, s32 dst, bool fromWater );
-
     StreamBase & operator<<( StreamBase &, const Step & );
     StreamBase & operator<<( StreamBase &, const Path & );
     StreamBase & operator>>( StreamBase &, Step & );

src/fheroes2/heroes/route_pathfind.cpp

@@ -112,7 +112,7 @@ bool PassableToTile( const Maps::Tiles & toTile, int direct, s32 dst, bool fromW
     return true;
 }
 
-bool Route::PassableFromToTile( s32 from, s32 to, int direct, s32 dst, bool fromWater )
+bool PassableFromToTile( s32 from, s32 to, int direct, s32 dst, bool fromWater )
 {
     const Maps::Tiles & fromTile = world.GetTiles( from );
     const Maps::Tiles & toTile = world.GetTiles( to );

src/fheroes2/maps/maps_tiles.cpp

@@ -1590,16 +1590,14 @@ void Maps::Tiles::RedrawPassable( Surface & dst ) const
     const Point mp = Maps::GetPoint( GetIndex() );
 
     if ( area.GetVisibleTileROI() & mp ) {
-        if ( 0 == tile_passable || DIRECTION_ALL != tile_passable ) {
             Surface sf = PassableViewSurface( tile_passable );
 
-            if ( passable_disable ) {
-                Text text( GetString( passable_disable ), Font::SMALL );
+            if ( test_value ) {
+                Text text( GetString( test_value ), Font::SMALL );
                 text.Blit( 13, 13, sf );
             }
 
             area.BlitOnTile( dst, sf, 0, 0, mp );
-        }
     }
 #endif
 }

src/fheroes2/maps/maps_tiles.h

@@ -262,6 +262,8 @@ namespace Maps
         static void UpdateAbandoneMineSprite( Tiles & );
         static void FixedPreload( Tiles & );
 
+        u16 test_value = 0;
+
     private:
         TilesAddon * FindFlags( void );
         void CorrectFlags32( u32 index, bool );

src/fheroes2/world/world.h

@@ -252,6 +252,9 @@ class World : protected Size
     MapObjectSimple * GetMapObject( u32 uid );
     void RemoveMapObject( const MapObjectSimple * );
 
+    bool isTileUnderProtection( int to, int dst );
+    bool isFinalTile( const Maps::Tiles & toTile, bool fromWater ) const;
+    bool isValidPath( int index, int direction ) const;
     uint32_t getDistance( int from, int to, uint32_t skill );
     std::list<Route::Step> getPath( int from, int to, uint32_t skill, bool ignoreObjects = true );
 

src/fheroes2/world/world_pathfinding.cpp

@@ -84,6 +84,96 @@ std::list<Route::Step> Pathfinder::buildPath( int from, int target, uint8_t skil
     return path;
 }
 
+bool World::isTileUnderProtection( int to, int dst )
+{
+    const MapsIndexes & monsters = Maps::GetTilesUnderProtection( to );
+    return monsters.size() && monsters.end() == std::find( monsters.begin(), monsters.end(), dst );
+}
+
+bool World::isFinalTile( const Maps::Tiles & toTile, bool fromWater ) const
+{
+    const bool toWater = toTile.isWater();
+    const int object = toTile.GetObject();
+
+    if ( object == MP2::OBJ_HEROES || object == MP2::OBJ_MONSTER )
+        return true;
+
+    if ( MP2::isPickupObject( object ) || MP2::isActionObject( object, fromWater ) )
+        return true;
+
+    if ( fromWater && !toTile.isWater() ) {
+        switch ( toTile.GetObject() ) {
+        case MP2::OBJ_BOAT:
+        case MP2::OBJ_MONSTER:
+        case MP2::OBJ_HEROES:
+            return false;
+
+        case MP2::OBJ_COAST:
+            return true;
+
+        default:
+            break;
+        }
+    }
+    else if ( !fromWater && toTile.isWater() ) {
+        switch ( toTile.GetObject() ) {
+        case MP2::OBJ_BOAT:
+            return true;
+
+        case MP2::OBJ_HEROES:
+            return true;
+
+        default:
+            break;
+        }
+    }
+    return false;
+}
+
+bool World::isValidPath(int index, int direction) const
+{
+    const Maps::Tiles & fromTile = GetTiles( index );
+    const Maps::Tiles & toTile = GetTiles( Maps::GetDirectionIndex( index, direction ) );
+    const bool fromWater = fromTile.isWater();
+
+    // check corner water/coast
+    if ( fromWater ) {
+        switch ( direction ) {
+        case Direction::TOP_LEFT:
+            if ( !GetTiles( Maps::GetDirectionIndex( index, Direction::TOP ) ).isWater()
+                 || !GetTiles( Maps::GetDirectionIndex( index, Direction::LEFT ) ).isWater() )
+                return false;
+            break;
+
+        case Direction::TOP_RIGHT:
+            if ( !GetTiles( Maps::GetDirectionIndex( index, Direction::TOP ) ).isWater()
+                 || !GetTiles( Maps::GetDirectionIndex( index, Direction::RIGHT ) ).isWater() )
+                return false;
+            break;
+
+        case Direction::BOTTOM_RIGHT:
+            if ( !GetTiles( Maps::GetDirectionIndex( index, Direction::BOTTOM ) ).isWater()
+                 || !GetTiles( Maps::GetDirectionIndex( index, Direction::RIGHT ) ).isWater() )
+                return false;
+            break;
+
+        case Direction::BOTTOM_LEFT:
+            if ( !GetTiles( Maps::GetDirectionIndex( index, Direction::BOTTOM ) ).isWater()
+                 || !GetTiles( Maps::GetDirectionIndex( index, Direction::LEFT ) ).isWater() )
+                return false;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    if ( !fromTile.isPassable( direction, fromWater, false ) )
+        return false;
+
+    return toTile.isPassable( Direction::Reflect( direction ), fromWater, false );
+}
+
 bool Pathfinder::isBlockedByObject( int from, int target )
 {
     int currentNode = target;
@@ -127,6 +217,7 @@ uint32_t Pathfinder::getMovementPenalty( int from, int target, int direction, ui
 // Destination is optional
 void Pathfinder::evaluateMap( int start, uint8_t skill, int destination )
 {
+    const Directions directions = Direction::All();
     const bool fromWater = world.GetTiles( start ).isWater();
     const int width = world.w();
     const int height = world.h();
@@ -143,14 +234,13 @@ void Pathfinder::evaluateMap( int start, uint8_t skill, int destination )
     size_t lastProcessedNode = 0;
     while ( lastProcessedNode != nodesToExplore.size() ) {
         const int currentNodeIdx = nodesToExplore[lastProcessedNode];
-        for ( uint8_t direction = 0; direction < 8; ++direction ) {
-            const int dirBitmask = GetDirectionBitmask( direction );
-            if ( Maps::isValidDirection( currentNodeIdx, dirBitmask ) ) {
-                const int newIndex = Maps::GetDirectionIndex( currentNodeIdx, dirBitmask );
+        for ( auto it = directions.begin(); it != directions.end(); ++it ) {
+            if ( Maps::isValidDirection( currentNodeIdx, *it ) ) {
+                const int newIndex = Maps::GetDirectionIndex( currentNodeIdx, *it );
                 Maps::Tiles & newTile = world.GetTiles( newIndex );
 
-                uint32_t moveCost = _cache[currentNodeIdx]._cost + getMovementPenalty( currentNodeIdx, newIndex, skill );
-                if ( Route::PassableFromToTile( currentNodeIdx, newIndex, dirBitmask, destination, fromWater ) ) {
+                uint32_t moveCost = _cache[currentNodeIdx]._cost + getMovementPenalty( currentNodeIdx, newIndex, *it, skill );
+                if ( world.isValidPath( currentNodeIdx, *it ) ) {
                     if ( _cache[newIndex]._from == -1 || _cache[newIndex]._cost > moveCost ) {
                         _cache[newIndex]._from = currentNodeIdx;
                         _cache[newIndex]._cost = moveCost;