Merge branch 'ihhub:master' into feature/add-aspect-ratio-info

Author: Osmodium

src/engine/system.cpp

@@ -1,6 +1,6 @@
 /***************************************************************************
  *   fheroes2: https://github.com/ihhub/fheroes2                           *
- *   Copyright (C) 2019 - 2022                                             *
+ *   Copyright (C) 2019 - 2023                                             *
  *                                                                         *
  *   Free Heroes2 Engine: http://sourceforge.net/projects/fheroes2         *
  *   Copyright (C) 2009 by Andrey Afletdinov <[email protected]>          *
@@ -24,7 +24,9 @@
 #include <algorithm>
 #include <cassert>
 #include <cstdlib>
+#include <filesystem>
 #include <initializer_list>
+#include <system_error>
 #include <utility>
 
 #if defined( _WIN32 )
@@ -166,6 +168,50 @@ namespace
 
         return path;
     }
+
+    bool globMatch( const std::string_view string, const std::string_view wildcard )
+    {
+        size_t stringIdx = 0;
+        size_t wildcardIdx = 0;
+
+        size_t fallbackStringIdx = std::string_view::npos;
+        size_t fallbackWildcardIdx = std::string_view::npos;
+
+        while ( stringIdx < string.length() ) {
+            const bool isWildcardNotEnded = ( wildcardIdx < wildcard.length() );
+
+            if ( isWildcardNotEnded && wildcard[wildcardIdx] == '*' ) {
+                ++wildcardIdx;
+
+                fallbackStringIdx = stringIdx;
+                fallbackWildcardIdx = wildcardIdx;
+            }
+            else if ( isWildcardNotEnded && ( wildcard[wildcardIdx] == '?' || wildcard[wildcardIdx] == string[stringIdx] ) ) {
+                ++stringIdx;
+                ++wildcardIdx;
+            }
+            else {
+                if ( fallbackWildcardIdx == std::string_view::npos ) {
+                    return false;
+                }
+
+                assert( fallbackStringIdx != std::string_view::npos );
+
+                ++fallbackStringIdx;
+
+                stringIdx = fallbackStringIdx;
+                wildcardIdx = fallbackWildcardIdx;
+            }
+        }
+
+        for ( ; wildcardIdx < wildcard.length(); ++wildcardIdx ) {
+            if ( wildcard[wildcardIdx] != '*' ) {
+                break;
+            }
+        }
+
+        return wildcardIdx == wildcard.length();
+    }
 }
 
 bool System::isHandheldDevice()
@@ -177,6 +223,15 @@ bool System::isHandheldDevice()
 #endif
 }
 
+bool System::isShellLevelGlobbingSupported()
+{
+#if defined( _WIN32 )
+    return false;
+#else
+    return true;
+#endif
+}
+
 bool System::MakeDirectory( const std::string & path )
 {
 #if defined( _WIN32 )
@@ -482,6 +537,48 @@ bool System::GetCaseInsensitivePath( const std::string & path, std::string & cor
 }
 #endif
 
+void System::globFiles( const std::string_view glob, std::vector<std::string> & fileNames )
+{
+    const std::filesystem::path globPath( glob );
+
+    std::filesystem::path dir = globPath.parent_path();
+    if ( dir.empty() ) {
+        dir = std::filesystem::path{ "." };
+    }
+
+    std::error_code ec;
+
+    // Using the non-throwing overload
+    if ( !std::filesystem::is_directory( dir, ec ) ) {
+        fileNames.emplace_back( glob );
+        return;
+    }
+
+    const std::string pattern = globPath.filename().string();
+
+    if ( pattern.find( '*' ) == std::string_view::npos && pattern.find( '?' ) == std::string_view::npos ) {
+        fileNames.emplace_back( glob );
+        return;
+    }
+
+    bool isNoMatches = true;
+
+    // Using the non-throwing overload
+    for ( const std::filesystem::directory_entry & entry : std::filesystem::directory_iterator( dir, ec ) ) {
+        const std::filesystem::path & entryPath = entry.path();
+
+        if ( globMatch( entryPath.filename().string(), pattern ) ) {
+            fileNames.push_back( entryPath.string() );
+
+            isNoMatches = false;
+        }
+    }
+
+    if ( isNoMatches ) {
+        fileNames.emplace_back( glob );
+    }
+}
+
 std::string System::FileNameToUTF8( const std::string & name )
 {
 #if defined( _WIN32 )

src/engine/system.h

@@ -1,6 +1,6 @@
 /***************************************************************************
  *   fheroes2: https://github.com/ihhub/fheroes2                           *
- *   Copyright (C) 2019 - 2022                                             *
+ *   Copyright (C) 2019 - 2023                                             *
  *                                                                         *
  *   Free Heroes2 Engine: http://sourceforge.net/projects/fheroes2         *
  *   Copyright (C) 2013 by Andrey Afletdinov <[email protected]>          *
@@ -32,6 +32,9 @@
 namespace System
 {
     bool isHandheldDevice();
+    // Returns true if target platform supports shell-level globbing (Unix-like platforms with POSIX-compatible shells).
+    // Otherwise returns false, which means that app need to resolve wildcard patterns itself (for example, on Windows).
+    bool isShellLevelGlobbingSupported();
 
     bool MakeDirectory( const std::string & path );
     std::string concatPath( const std::string_view left, const std::string_view right );
@@ -49,6 +52,12 @@ namespace System
 
     bool GetCaseInsensitivePath( const std::string & path, std::string & correctedPath );
 
+    // Resolves the wildcard pattern 'glob' and appends matching paths to 'fileNames'. Supported wildcards are '?' and '*'.
+    // These wildcards are resolved only if they are in the last element of the path. For example, they will be resolved
+    // in the case of the 'foo/b*r?' pattern, but they will be ignored (used as is) in the case of '*/bar' pattern. If there
+    // are no files matching the pattern, it will be appended to the 'fileNames' as is.
+    void globFiles( const std::string_view glob, std::vector<std::string> & fileNames );
+
     std::string FileNameToUTF8( const std::string & name );
 
     tm GetTM( const time_t time );

src/tools/icn2img.cpp

@@ -1,6 +1,6 @@
 /***************************************************************************
  *   fheroes2: https://github.com/ihhub/fheroes2                           *
- *   Copyright (C) 2022                                                    *
+ *   Copyright (C) 2022 - 2023                                             *
  *                                                                         *
  *   Free Heroes2 Engine: http://sourceforge.net/projects/fheroes2         *
  *   Copyright (C) 2009 by Andrey Afletdinov <[email protected]>          *
@@ -23,11 +23,14 @@
 
 #include <cstdint>
 #include <cstdlib>
+#include <filesystem>
 #include <iomanip>
 #include <iostream>
 #include <memory>
 #include <sstream> // IWYU pragma: keep
 #include <string>
+#include <system_error>
+#include <type_traits>
 #include <vector>
 
 #include "agg_file.h"
@@ -39,85 +42,103 @@
 
 int main( int argc, char ** argv )
 {
-    if ( argc != 4 ) {
-        std::cout << argv[0] << " inputFile.icn destinationDirectory paletteFileName.pal" << std::endl;
+    if ( argc < 4 ) {
+        std::cerr << argv[0] << " destinationDirectory paletteFileName.pal inputFile.icn ..." << std::endl;
         return EXIT_FAILURE;
     }
 
-    std::string inputFileName( argv[1] );
-    std::string prefix( argv[2] );
-
-    std::string paletteFileName( argv[3] );
+    const char * dstDir = argv[1];
+    const char * paletteFileName = argv[2];
 
     StreamFile paletteFile;
     if ( !paletteFile.open( paletteFileName, "rb" ) ) {
-        std::cout << "Cannot open " << paletteFileName << std::endl;
+        std::cerr << "Cannot open " << paletteFileName << std::endl;
         return EXIT_FAILURE;
     }
 
-    std::vector<uint8_t> palette = paletteFile.getRaw();
+    const std::vector<uint8_t> palette = paletteFile.getRaw();
     if ( palette.size() != 768 ) {
-        std::cout << "Invalid palette size of " << palette.size() << " instead of 768." << std::endl;
+        std::cerr << "Invalid palette size of " << palette.size() << " instead of 768." << std::endl;
         return EXIT_FAILURE;
     }
 
     fheroes2::setGamePalette( palette );
 
-    StreamFile sf;
-
-    if ( !sf.open( inputFileName, "rb" ) ) {
-        std::cout << "Cannot open " << inputFileName << std::endl;
-        return EXIT_FAILURE;
+    std::vector<std::string> inputFileNames;
+    for ( int i = 3; i < argc; ++i ) {
+        if ( System::isShellLevelGlobbingSupported() ) {
+            inputFileNames.emplace_back( argv[i] );
+        }
+        else {
+            System::globFiles( argv[i], inputFileNames );
+        }
     }
 
-    int count_sprite = sf.getLE16();
-    int total_size = sf.getLE32();
+    for ( const std::string & inputFileName : inputFileNames ) {
+        StreamFile sf;
 
-    inputFileName.replace( inputFileName.find( ".icn" ), 4, "" );
-    prefix = System::concatPath( prefix, inputFileName );
+        if ( !sf.open( inputFileName, "rb" ) ) {
+            std::cerr << "Cannot open " << inputFileName << std::endl;
+            return EXIT_FAILURE;
+        }
 
-    if ( 0 != System::MakeDirectory( prefix ) ) {
-        std::cout << "error mkdir: " << prefix << std::endl;
-        return EXIT_SUCCESS;
-    }
+        const std::filesystem::path prefix = std::filesystem::path( dstDir ) / std::filesystem::path( inputFileName ).stem();
+
+        std::error_code ec;
+
+        // Using the non-throwing overloads
+        if ( !std::filesystem::exists( prefix, ec ) && !std::filesystem::create_directories( prefix, ec ) ) {
+            std::cerr << "Cannot create directory " << prefix << std::endl;
+            return EXIT_FAILURE;
+        }
+
+        std::cout << std::endl << "Processing " << inputFileName << "..." << std::endl << std::endl;
 
-    size_t save_pos = sf.tell();
+        const uint16_t spritesCount = sf.getLE16();
+        const uint32_t totalSize = sf.getLE32();
 
-    std::vector<fheroes2::ICNHeader> headers( count_sprite );
-    for ( int ii = 0; ii < count_sprite; ++ii )
-        sf >> headers[ii];
+        const size_t beginPos = sf.tell();
 
-    for ( int ii = 0; ii < count_sprite; ++ii ) {
-        const fheroes2::ICNHeader & head = headers[ii];
+        std::vector<fheroes2::ICNHeader> headers( spritesCount );
+        for ( fheroes2::ICNHeader & header : headers ) {
+            sf >> header;
+        }
 
-        uint32_t data_size = ( ii + 1 != count_sprite ? headers[ii + 1].offsetData - head.offsetData : total_size - head.offsetData );
-        sf.seek( save_pos + head.offsetData );
-        std::cerr << data_size << std::endl;
-        std::vector<uint8_t> buf = sf.getRaw( data_size );
+        for ( uint16_t spriteIdx = 0; spriteIdx < spritesCount; ++spriteIdx ) {
+            const fheroes2::ICNHeader & header = headers[spriteIdx];
 
-        if ( !buf.empty() ) {
-            const fheroes2::Sprite image = fheroes2::decodeICNSprite( &buf[0], data_size, head.width, head.height, head.offsetX, head.offsetY );
+            sf.seek( beginPos + header.offsetData );
+
+            const uint32_t dataSize = ( spriteIdx + 1 < spritesCount ? headers[spriteIdx + 1].offsetData - header.offsetData : totalSize - header.offsetData );
+
+            const std::vector<uint8_t> buf = sf.getRaw( dataSize );
+            if ( buf.empty() ) {
+                continue;
+            }
+
+            const fheroes2::Sprite image = fheroes2::decodeICNSprite( buf.data(), dataSize, header.width, header.height, header.offsetX, header.offsetY );
 
             std::ostringstream os;
-            os << std::setw( 3 ) << std::setfill( '0' ) << ii;
+            os << std::setw( 3 ) << std::setfill( '0' ) << spriteIdx;
 
-            std::string dstfile = System::concatPath( prefix, os.str() );
+            std::string dstFileName = ( prefix / os.str() ).string();
 
             if ( fheroes2::isPNGFormatSupported() ) {
-                dstfile += ".png";
+                dstFileName += ".png";
             }
             else {
-                dstfile += ".bmp";
+                dstFileName += ".bmp";
             }
 
-            std::cout << "Image " << ii + 1 << " has offset of [" << static_cast<int32_t>( head.offsetX ) << ", " << static_cast<int32_t>( head.offsetY ) << "]"
-                      << std::endl;
+            static_assert( std::is_same_v<decltype( header.offsetX ), uint16_t> && std::is_same_v<decltype( header.offsetY ), uint16_t>,
+                           "Offset types have been changed, check the casts below" );
 
-            fheroes2::Save( image, dstfile, 23 );
+            std::cout << "Image " << spriteIdx + 1 << " has offset of [" << static_cast<int16_t>( header.offsetX ) << ", " << static_cast<int16_t>( header.offsetY )
+                      << "]" << std::endl;
+
+            fheroes2::Save( image, dstFileName, 23 );
         }
     }
 
-    sf.close();
-
     return EXIT_SUCCESS;
 }