Random terrain generation

fheroes2-vs2019.vcxproj

@@ -18,6 +18,12 @@
       <Platform>x64</Platform>
     </ProjectConfiguration>
   </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\fheroes2\maps\map_generator.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="src\fheroes2\maps\map_generator.h" />
+  </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectGuid>{DD8F214C-C405-4951-8F98-66B969BA8E08}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
@@ -48,4 +54,4 @@
     <Import Project="VisualStudio\fheroes2\Release.props" />
   </ImportGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-</Project>
+</Project>

src/fheroes2/editor/editor_interface.cpp

@@ -30,6 +30,9 @@
 #include <string>
 #include <vector>
 
+#include <logging.h>
+#include <rand.h>
+
 #include "agg_image.h"
 #include "artifact.h"
 #include "audio_manager.h"
@@ -55,6 +58,7 @@
 #include "interface_radar.h"
 #include "localevent.h"
 #include "map_format_helper.h"
+#include "map_generator.h"
 #include "map_object_info.h"
 #include "maps.h"
 #include "maps_tiles.h"
@@ -103,60 +107,6 @@ namespace
         return { startPos.x + startPos.y * worldWidth, endPos.x + endPos.y * worldWidth };
     }
 
-    bool isObjectPlacementAllowed( const Maps::ObjectInfo & info, const fheroes2::Point & mainTilePos )
-    {
-        // Run through all tile offsets and check that all objects parts can be put on the map.
-        for ( const auto & objectPart : info.groundLevelParts ) {
-            if ( objectPart.layerType == Maps::SHADOW_LAYER ) {
-                // Shadow layer parts are ignored.
-                continue;
-            }
-
-            if ( !Maps::isValidAbsPoint( mainTilePos.x + objectPart.tileOffset.x, mainTilePos.y + objectPart.tileOffset.y ) ) {
-                return false;
-            }
-        }
-
-        for ( const auto & objectPart : info.topLevelParts ) {
-            if ( !Maps::isValidAbsPoint( mainTilePos.x + objectPart.tileOffset.x, mainTilePos.y + objectPart.tileOffset.y ) ) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    bool isActionObjectAllowed( const Maps::ObjectInfo & info, const fheroes2::Point & mainTilePos )
-    {
-        // Active action object parts must be placed on a tile without any other objects.
-        // Only ground parts should be checked for this condition.
-        for ( const auto & objectPart : info.groundLevelParts ) {
-            if ( objectPart.layerType == Maps::SHADOW_LAYER || objectPart.layerType == Maps::TERRAIN_LAYER ) {
-                // Shadow and terrain layer parts are ignored.
-                continue;
-            }
-
-            const fheroes2::Point pos{ mainTilePos.x + objectPart.tileOffset.x, mainTilePos.y + objectPart.tileOffset.y };
-            if ( !Maps::isValidAbsPoint( pos.x, pos.y ) ) {
-                return false;
-            }
-
-            const auto & tile = world.GetTiles( pos.x, pos.y );
-
-            if ( MP2::isActionObject( tile.GetObject() ) ) {
-                // An action already exist. We cannot allow to put anything on top of it.
-                return false;
-            }
-
-            if ( MP2::isActionObject( objectPart.objectType ) && !Maps::isClearGround( tile ) ) {
-                // We are trying to place an action object on a tile that has some other objects.
-                return false;
-            }
-        }
-
-        return true;
-    }
-
     bool isConditionValid( const std::vector<fheroes2::Point> & offsets, const fheroes2::Point & mainTilePos,
                            const std::function<bool( const Maps::Tiles & tile )> & condition )
     {
@@ -581,6 +531,34 @@ namespace Interface
                 else if ( HotKeyPressEvent( Game::HotKeyEvent::WORLD_VIEW_WORLD ) ) {
                     eventViewWorld();
                 }
+#if defined( WITH_DEBUG )
+                else if ( HotKeyPressEvent( Game::HotKeyEvent::EDITOR_RANDOM_MAP_GENERATION ) ) {
+                    fheroes2::ActionCreator action( _historyManager, _mapFormat );
+
+                    Maps::Generator::Configuration rmgConfig;
+                    rmgConfig.playerCount = _playerCount;
+                    rmgConfig.regionSizeLimit = _regionSizeLimit;
+
+                    if ( Maps::Generator::generateWorld( _mapFormat, rmgConfig ) ) {
+                        _redraw |= mapUpdateFlags;
+
+                        action.commit();
+                    }
+                    else {
+                        _warningMessage.reset( _( "Not able to generate a map with given parameters." ) );
+                    }
+                }
+                else if ( HotKeyPressEvent( Game::HotKeyEvent::EDITOR_RANDOM_MAP_CONFIGURATION ) ) {
+                    uint32_t newCount = _playerCount;
+                    if ( Dialog::SelectCount( "Pick player count", 2, 6, newCount ) ) {
+                        _playerCount = newCount;
+                    }
+                    newCount = _regionSizeLimit;
+                    if ( Dialog::SelectCount( "Limit region size", 100, 10000, newCount ) ) {
+                        _regionSizeLimit = newCount;
+                    }
+                }
+#endif
                 // map scrolling control
                 else if ( HotKeyPressEvent( Game::HotKeyEvent::WORLD_SCROLL_LEFT ) ) {
                     _gameArea.SetScroll( SCROLL_LEFT );

src/fheroes2/editor/editor_interface.h

@@ -147,6 +147,9 @@ namespace Interface
         int32_t _selectedTile{ -1 };
         int32_t _tileUnderCursor{ -1 };
 
+        uint32_t _playerCount = 2;
+        uint32_t _regionSizeLimit = 600;
+
         std::function<void( const int32_t )> _cursorUpdater;
 
         fheroes2::HistoryManager _historyManager;

src/fheroes2/game/game_hotkeys.cpp

@@ -161,6 +161,13 @@ namespace
         hotKeyEventInfo[hotKeyEventToInt( Game::HotKeyEvent::EDITOR_TO_GAME_MAIN_MENU )]
             = { Game::HotKeyCategory::EDITOR, gettext_noop( "hotkey|open game main menu" ), fheroes2::Key::KEY_M };
 
+#if defined( WITH_DEBUG )
+        hotKeyEventInfo[hotKeyEventToInt( Game::HotKeyEvent::EDITOR_RANDOM_MAP_GENERATION )]
+            = { Game::HotKeyCategory::WORLD_MAP, gettext_noop( "hotkey|generate random map" ), fheroes2::Key::KEY_F5 };
+        hotKeyEventInfo[hotKeyEventToInt( Game::HotKeyEvent::EDITOR_RANDOM_MAP_CONFIGURATION )]
+            = { Game::HotKeyCategory::WORLD_MAP, gettext_noop( "hotkey|configure random map generator" ), fheroes2::Key::KEY_F6 };
+#endif
+
         hotKeyEventInfo[hotKeyEventToInt( Game::HotKeyEvent::CAMPAIGN_ROLAND )]
             = { Game::HotKeyCategory::CAMPAIGN, gettext_noop( "hotkey|roland campaign" ), fheroes2::Key::KEY_1 };
         hotKeyEventInfo[hotKeyEventToInt( Game::HotKeyEvent::CAMPAIGN_ARCHIBALD )]

src/fheroes2/game/game_hotkeys.h

@@ -75,6 +75,12 @@ namespace Game
         EDITOR_REDO_LAST_ACTION,
         EDITOR_TO_GAME_MAIN_MENU,
 
+#if defined( WITH_DEBUG )
+        // This hotkey is only for debug mode as of now.
+        EDITOR_RANDOM_MAP_GENERATION,
+        EDITOR_RANDOM_MAP_CONFIGURATION,
+#endif
+
         CAMPAIGN_ROLAND,
         CAMPAIGN_ARCHIBALD,
         CAMPAIGN_PRICE_OF_LOYALTY,

src/fheroes2/gui/ui_map_object.cpp

@@ -270,4 +270,105 @@ namespace fheroes2
 
         return 0;
     }
+
+    constexpr int32_t mineIndexFromGroundType( const int groundType )
+    {
+        switch ( groundType ) {
+        case Maps::Ground::WATER:
+            // Logically Water is not allowed but let's do this.
+            assert( 0 );
+            return 0;
+        case Maps::Ground::GRASS:
+            return 1;
+        case Maps::Ground::SNOW:
+            return 2;
+        case Maps::Ground::SWAMP:
+            return 3;
+        case Maps::Ground::LAVA:
+            return 4;
+        case Maps::Ground::DESERT:
+            return 5;
+        case Maps::Ground::DIRT:
+            return 6;
+        case Maps::Ground::WASTELAND:
+            return 7;
+        case Maps::Ground::BEACH:
+            return 0;
+        default:
+            // Have you added a new ground? Add the logic above!
+            assert( 0 );
+            break;
+        }
+        return 0;
+    }
+
+    constexpr int32_t sawmillIndexFromGroundType( const int groundType )
+    {
+        switch ( groundType ) {
+        case Maps::Ground::WATER:
+            // Logically Water is not allowed but let's do this.
+            assert( 0 );
+            return 0;
+        case Maps::Ground::GRASS:
+            return 0;
+        case Maps::Ground::SNOW:
+            return 1;
+        case Maps::Ground::SWAMP:
+            return 0;
+        case Maps::Ground::LAVA:
+            return 2;
+        case Maps::Ground::DESERT:
+            return 3;
+        case Maps::Ground::DIRT:
+            return 4;
+        case Maps::Ground::WASTELAND:
+            return 5;
+        case Maps::Ground::BEACH:
+            return 3;
+        default:
+            // Have you added a new ground? Add the logic above!
+            assert( 0 );
+            break;
+        }
+        return 0;
+    }
+
+    int32_t getMineObjectInfoId( const int resource, const int groundType )
+    {
+        // 8 terrain and 5 resources
+        // 2 abandoned mines: grass & dirt
+        // Sawmills for different terrains: Grass/Swamp, Snow, Lava, Desert, Dirt, Wasteland.
+        // 2 alchemists labs: regular and snow
+
+        // if you add new mine type update this logic!
+        assert( Maps::getObjectsByGroup( Maps::ObjectGroup::ADVENTURE_MINES ).size() == 50 );
+
+        const int groundIndex = mineIndexFromGroundType( groundType );
+
+        switch ( resource ) {
+        case Resource::ORE:
+            return groundIndex * 5;
+        case Resource::SULFUR:
+            return groundIndex * 5 + 1;
+        case Resource::CRYSTAL:
+            return groundIndex * 5 + 2;
+        case Resource::GEMS:
+            return groundIndex * 5 + 3;
+        case Resource::GOLD:
+            return groundIndex * 5 + 4;
+        case Resource::WOOD:
+            return 5 * 8 + 2 + sawmillIndexFromGroundType( groundType );
+        case Resource::MERCURY:
+            return groundType == Maps::Ground::SNOW ? 49 : 48;
+        case Resource::UNKNOWN:
+            // must be an abandoned mine
+            return groundType == Maps::Ground::GRASS ? 40 : 41;
+        default:
+            // Have you added a new resource type?!
+            assert( 0 );
+            break;
+        }
+
+        return 0;
+    }
 }

src/fheroes2/gui/ui_map_object.h

@@ -35,4 +35,5 @@ namespace fheroes2
     Sprite generateTownObjectImage( const int townType, const int color, const int groundId );
 
     int32_t getTownBasementId( const int groundType );
+    int32_t getMineObjectInfoId( const int resource, const int groundType );
 }