CMakeLists.txt

@@ -4,21 +4,31 @@ project(sliding-puzzle LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(SOURCES application.cpp board.cpp main.cpp argsprocessor.cpp)
-set(HEADER_FILES application.h board.h filepath_util.h output_util.h argsprocessor.h)
+set(SOURCES application.cpp board.cpp main.cpp)
+set(HEADER_FILES application.h board.h filepath_util.h output_util.h)
+
+set(SFML_STATIC_LIBRARIES TRUE) #set to FALSE if you have sfml installed from package manager and you don't want to link it statically
 
 # STATIC #
 # You need to build SFML from sources with cmake
+if (SFML_STATIC_LIBRARIES)
     set(SFML_LIB_DIR
         ${CMAKE_SOURCE_DIR}/SFML-2.5.1/lib/libsfml-graphics.so.2.5
         ${CMAKE_SOURCE_DIR}/SFML-2.5.1/lib/libsfml-system.so.2.5
         ${CMAKE_SOURCE_DIR}/SFML-2.5.1/lib/libsfml-window.so.2.5)
-#set(SFML_INCL_DIR ${CMAKE_SOURCE_DIR}/SFML-2.5.1/include)
-#include_directories(${SFML_INCL_DIR})
-#target_link_libraries(sliding-puzzle ${SFML_LIB_DIR})
+    set(SFML_INCL_DIR ${CMAKE_SOURCE_DIR}/SFML-2.5.1/include)
+
+    include_directories(${SFML_INCL_DIR})
+
+    add_executable(sliding-puzzle ${SOURCES} ${HEADER_FILES} )
+    target_link_libraries(sliding-puzzle ${SFML_LIB_DIR})
+endif()
 
 # DYNAMIC #
 # You only need to install SFML from your package manager
+if (NOT SFML_STATIC_LIBRARIES)
     find_package(SFML REQUIRED graphics window system)
+    include_directories(${SFML_INCLUDE_DIR})
     add_executable(sliding-puzzle ${SOURCES} ${HEADER_FILES} )
-target_link_libraries(sliding-puzzle sfml-system sfml-graphics sfml-network)
+    target_link_libraries(sliding-puzzle ${SFML_LIBRARIES} ${SFML_DEPENDENCIES})
+endif()

LICENSE

@@ -1,24 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to <https://unlicense.org>

README.md

@@ -1,39 +0,0 @@
-# sliding-puzzle
-A simple game which takes an image, then slices it into tiles and shuffles. You need to restore the initial image by swapping neighbor tiles! It's a command line application and does support --help.
-
-### How to build
-You only need a compiler supporting c++17 and sfml 2.5.1 (or latter versions).
-
-First of all, clone the project and go to the project folder
-```
-git clone https://dev.udongein.xyz/NaiJi/sliding-puzzle
-cd sliding-puzzle/
-```
-
-Then simply build it with CMake
-```
-cmake CMakeLists.txt -B ../sliding-puzzle-build
-cd ../sliding-puzzle-build
-make
-```
-
-### Usage
-Run it from terminal, providing optional flags and filepath. Move cursor by either WASD or arrows. Press Z to select a tile and then select a direction to swap the tile with a neighbor from that direction. Repeat until the inital image gets completely assembled!
-```
-usage: sliding-puzzle [-OPTIONS...] FILE-OR-DIRECTORY
-
-    Provide FILE-OR-DIRECTORY variable as a path to either a directory
-    which contains images (one will be picked randomly) or a specific
-    image file of .bmp, .jpg, of .png format.
-
-    If no path was provided, it will be assumed as '.'!
-
-    Options:
-      [-r NUMxNUM] Provide it if you want to explicitly define
-                   window resolution.
-      [-s NUM]     Provide it if you want to explicitly define
-                   qualifier for image slicing, it's counted
-                   by the smallest side of given source texture.
-                   Hence, if your image is square, the amount of tiles
-                   will be num * num.
-```

application.cpp

@@ -61,13 +61,14 @@ void Application::onGameState(sf::Event& event)
         break;
 
     case sf::Event::KeyPressed:
+        // Go to selection mode
         if (event.key.code == sf::Keyboard::Z)
             board.onSelectionMode();
-        else
-            board.tryProcessDirection(getDirection(event.key.code));
+        else // if it wasn't selection mode, then try to handle direction
+            board.moveSelection(getDirection(event.key.code));
         break;
 
-    default:
+    default:   // otherwise - do nothing
         break;
     }
 

argsprocessor.cpp

@@ -1,141 +0,0 @@
-#include "argsprocessor.h"
-#include "output_util.h"
-#include "filepath_util.h"
-
-#include <cstring>
-#include <cctype>
-
-/////////////////////////////////////////////////////////////////////////
-
-static constexpr int DEFAULT_SCREEN_WIDTH   = 1280;
-static constexpr int DEFAULT_SCREEN_HEIGHT  = 720;
-static constexpr int DEFAULT_SPLITTING = 4;
-static const char * const DEFAULT_PATH = ".";
-
-/////////////////////////////////////////////////////////////////////////
-
-ArgsProcessor::ArgsProcessor(int argc, char **argv) :
-    image_splitting(DEFAULT_SPLITTING),
-    game_resolution({DEFAULT_SCREEN_WIDTH, DEFAULT_SCREEN_HEIGHT}),
-    image_path(DEFAULT_PATH)
-{
-    parse_result = tryConvertInput(argc, argv);
-}
-
-int ArgsProcessor::broken() const
-{
-    return parse_result;
-}
-
-std::tuple<int, sf::Vector2i, std::string> ArgsProcessor::unpack() const
-{
-    return {image_splitting, game_resolution, image_path};
-}
-
-int ArgsProcessor::tryConvertInput(int argc, char **argv)
-{
-    int error = iterateArgc(argc, argv);
-    if (error)
-        return error;
-
-    if (image_path == DEFAULT_PATH && loaded_image_pathes.empty())
-    {
-        // no path was given, loading random image from '.'
-        const auto &[error, ret_path] = filepath::parsePath(image_path);
-        if (error)
-            return makeError(output::IMG_FAIL_MSG);
-
-       loaded_image_pathes.insert(loaded_image_pathes.end(), ret_path.begin(), ret_path.end());
-    }
-
-    image_path = filepath::randomChoice(loaded_image_pathes);
-
-    return EXIT_SUCCESS;
-}
-
-bool ArgsProcessor::isFlag(const char *arg, const char *flag) const
-{
-    return (strcmp(arg, flag) == 0);
-}
-
-int ArgsProcessor::iterateArgc(int argc, char **argv)
-{
-    for (int current_arg = 1; current_arg < argc; ++current_arg) // current_arg = 0 is executable name
-    {
-        if (isFlag(argv[current_arg], output::HELP_FLAG))
-            return makeError(output::HELP_MSG);
-
-        if (isFlag(argv[current_arg], output::SPLITTING_FLAG))
-        {
-            int error = parseSplitting(current_arg, argc, argv);
-            if (error)
-                return error;
-
-            ++current_arg;
-            continue;
-        }
-
-        if (isFlag(argv[current_arg], output::RESOLUTION_FLAG))
-        {
-            int error = parseResolution(current_arg, argc, argv);
-            if (error)
-                return error;
-
-            ++current_arg;
-            continue;
-        }
-
-        const auto &[error, ret_path] = filepath::parsePath(argv[current_arg]);
-
-        if (error)
-            continue;
-
-        loaded_image_pathes.insert(loaded_image_pathes.end(), ret_path.begin(), ret_path.end());
-    }
-
-    return EXIT_SUCCESS;
-}
-
-int ArgsProcessor::parseSplitting(int curr_arg, int argc, char **argv)
-{
-    const int value_rg = curr_arg + 1;
-    if (value_rg == argc)
-        return makeError(output::SPLITTING_MSG);
-
-    image_splitting = -1;
-    if (std::isdigit(*argv[value_rg]))
-        image_splitting = std::stoi(argv[value_rg]);
-
-    if (image_splitting < 2)
-        return makeError(output::SPLITTING_MSG);
-
-    return EXIT_SUCCESS;
-}
-
-int ArgsProcessor::parseResolution(int curr_arg, int argc, char **argv)
-{
-    const int value_rg = curr_arg + 1;
-    if (value_rg == argc)
-        return makeError(output::RESOLUTION_MSG);
-
-    std::vector<std::string> res = filepath::split(argv[value_rg], 'x');  // splitting argument by 'x' as in 600x900
-
-    if (res.size() < 2)
-        return makeError(output::RESOLUTION_MSG);
-
-    game_resolution = {-1, -1};
-
-    if (std::isdigit(*res[0].c_str()) && std::isdigit(*res[1].c_str()))
-        game_resolution = {std::stoi(res[0].c_str()), std::stoi(res[1].c_str())};
-
-    if (game_resolution.x < 1 || game_resolution.y < 1)
-        return makeError(output::RESOLUTION_MSG);
-
-    return EXIT_SUCCESS;
-}
-
-int ArgsProcessor::makeError(const char* msg) const
-{
-    std::cout << msg;
-    return EXIT_FAILURE;
-}

argsprocessor.h

@@ -1,30 +0,0 @@
-#ifndef ARGSPROCESSOR_H
-#define ARGSPROCESSOR_H
-
-#include <SFML/Graphics/VertexArray.hpp>
-#include <string>
-
-class ArgsProcessor
-{
-public:
-    ArgsProcessor(int argc, char **argv);
-
-    int broken() const;
-    std::tuple<int, sf::Vector2i, std::string> unpack() const;
-
-private:
-    bool isFlag(const char* arg, const char* flag) const;
-    int tryConvertInput(int argc, char **argv);
-    int iterateArgc(int argc, char **argv);
-    int makeError(const char* msg) const;
-    int parseSplitting(int curr_arg, int argc, char **argv);
-    int parseResolution(int curr_arg, int argc, char **argv);
-
-    int parse_result;
-    int image_splitting;
-    sf::Vector2i game_resolution;
-    std::string image_path;
-    std::vector<std::string> loaded_image_pathes;
-};
-
-#endif // ARGSPROCESSOR_H

board.cpp

@@ -28,44 +28,32 @@ Board::~Board()
 
 bool Board::init(const std::string& path, int splitting, const sf::RenderWindow &window)
 {
-    std::cout << path << '\n';
+    // PREPARING INITIAL BOARD STATE //
+
     if (!global_texture.loadFromFile(path) )
         return false;
 
-    calculateBoardProperties(splitting);
-    splitImageIntoTiles(Cell::side_length);
-    scaleImageToWindow(window);
-    shuffleTiles();
-    setSelectionVertex(selection_index);
-
-    return true;
-}
-
-void Board::calculateBoardProperties(int splitting)
-{
     const int width  = global_texture.getSize().x;
     const int height = global_texture.getSize().y;
 
     Cell::side_length = (width < height) ? width / splitting : height / splitting;
     cells_on_height = height / Cell::side_length;
     cells_on_width  = width  / Cell::side_length;
-}
 
-void Board::splitImageIntoTiles(int tile_length)
-{
-    const int width  = global_texture.getSize().x;
-    const int height = global_texture.getSize().y;
+    vec_field.reserve(cells_on_height * cells_on_width);
 
+    /* Iterating board cells' screen positions.
+     * The initial image after this would look exactly like the loaded picture, not shuffled yet. */
     Cells::size_type index = 0;
-    for (int x = 0; x < height; x += tile_length)
+    for (int x = 0; x < height; x += Cell::side_length)
     {
-        if ((height - x) >= tile_length)
+        if ((height - x) >= Cell::side_length)
         {
-            for (int y = 0; y < width; y += tile_length)
+            for (int y = 0; y < width; y += Cell::side_length)
             {
-                if ((width - y) >= tile_length)
+                if ((width - y) >= Cell::side_length)
                 {
-                    sf::Sprite* sp = new sf::Sprite(global_texture, sf::IntRect(y, x, tile_length, tile_length));
+                    sf::Sprite* sp = new sf::Sprite(global_texture, sf::IntRect(y, x, Cell::side_length, Cell::side_length));
                     sp->setPosition(static_cast<float>(y), static_cast<float>(x));
 
                     vec_field.push_back(new Cell({index, index, sp}));
@@ -74,63 +62,43 @@ void Board::splitImageIntoTiles(int tile_length)
             }
         }
     }
-}
 
-void Board::scaleImageToWindow(const sf::RenderWindow &window)
-{
-    float scaling = calculateScalingToWindow(window);
-    scaleTiles(scaling);
-}
-
-float Board::calculateScalingToWindow(const sf::RenderWindow &window) const
-{
-    int texture_width  = global_texture.getSize().x;
-    int texture_height = global_texture.getSize().y;
+    // SCALING //
 
     float scaling = 0.;
-    if (texture_width >= texture_height && texture_width > static_cast<int>(window.getSize().x))
-        scaling = static_cast<float>(window.getSize().x) / static_cast<float>(texture_width);
-    if (texture_height >= texture_width && texture_height > static_cast<int>(window.getSize().y))
-        scaling = static_cast<float>(window.getSize().y) / static_cast<float>(texture_height);
+    if (width >= height && width > static_cast<int>(window.getSize().x))
+        scaling = static_cast<float>(window.getSize().x) / static_cast<float>(width);
+    if (height >= width && height > static_cast<int>(window.getSize().y))
+        scaling = static_cast<float>(window.getSize().y) / static_cast<float>(height);
 
-    return scaling;
-}
-
-void Board::scaleTiles(float scaling)
+    if (scaling != 0.)
     {
-    if (scaling == 0.)
-        return;
-
+        // Calculating new size of each tile
         int old_side_length = Cell::side_length;
         Cell::side_length = static_cast<int>(static_cast<float>(Cell::side_length) * scaling);
         int shift = Cell::side_length - old_side_length;
-
+        float move_x, move_y;
+        // Moving all scaled tiles up and left, to remove spacing
         for (Cells::size_type i = 0; i < vec_field.size(); ++i)
         {
-        vec_field[i]->sprite->scale(scaling, scaling);
-
-        const auto shift_vector = calculateTileShiftVector(i, shift);
-        vec_field[i]->sprite->move(shift_vector.first, shift_vector.second);
-    }
-}
-
-std::pair<float, float> Board::calculateTileShiftVector(Cells::size_type tile_index, int shift) const
-{
-    float move_x = 0.f, move_y = 0.f;
-
+            move_x = 0.f;
+            move_y = 0.f;
             // The first column isn't allowed to move by x
-    if (!(((tile_index % cells_on_width == 0) && (tile_index >= cells_on_width))))
-        move_x = static_cast<float>(shift) * static_cast<float>((tile_index < cells_on_width) ? tile_index : tile_index % cells_on_width);
-
+            if (!(((i % cells_on_width == 0) && (i >= cells_on_width))))
+                move_x = static_cast<float>(shift) * static_cast<float>((i < cells_on_width) ? i : i % cells_on_width);
             // The first row isn't allowed to move by y
-    if (tile_index >= cells_on_width)
-        move_y = static_cast<float>(shift) * static_cast<float>(tile_index / cells_on_width);
+            if (i >= cells_on_width)
+                move_y = static_cast<float>(shift) * static_cast<float>(i / cells_on_width);
 
-    return {move_x, move_y};
+            vec_field[i]->sprite->scale(scaling, scaling);
+            vec_field[i]->sprite->move(move_x, move_y);
         }
 
-void Board::shuffleTiles()
-{
+    }
+
+
+    // SHUFFLING //
+
     solved_tiles = vec_field.size(); // all tiles are solved for now
 
     srand(static_cast<unsigned int>(time(nullptr)));
@@ -144,6 +112,11 @@ void Board::shuffleTiles()
 
         swapCells(curr_i, swap_i);
     }
+
+    // Set initial position of cursor
+    setSelectionVertex(selection_index);
+
+    return true;
 }
 
 void Board::draw(sf::RenderWindow& window)
@@ -158,15 +131,9 @@ void Board::draw(sf::RenderWindow& window)
         window.draw(rect_selection);
 }
 
-bool Board::tryProcessDirection(const DIRECTION &direction)
-{
-    if (on_selection)
-        return swapOnSelection(direction);
-
-    return moveSelection(direction);
-}
-
 bool Board::moveSelection(const DIRECTION &direction)
+{
+    if (!on_selection)
     {
         switch (direction) {
         case DIRECTION::UP:
@@ -177,7 +144,7 @@ bool Board::moveSelection(const DIRECTION &direction)
             break;
 
         case DIRECTION::DOWN:
-        if (selection_index >= (cells_on_width * (cells_on_height - 1))) // if bottom row
+            if (selection_index > (cells_on_width * (cells_on_height - 1))) // if bottom row
                 return false;
             selection_index += cells_on_width;
             setSelectionVertex(selection_index);
@@ -206,8 +173,6 @@ bool Board::moveSelection(const DIRECTION &direction)
         return true;
     }
 
-bool Board::swapOnSelection(const DIRECTION &direction)
-{
     switch (direction) {
     case DIRECTION::UP:
         if (selection_index < cells_on_width) // if upper row
@@ -326,4 +291,4 @@ void Board::setCursorVisibility(bool visible)
     is_cursor_visible = visible;
 }
 
-int Board::Cell::side_length = 1;
+int Board::Cell::side_length = 0;

board.h

@@ -27,20 +27,27 @@ public:
     explicit Board();
     ~Board();
 
+    // Set play image
     bool init(const std::string& path, int splitting, const sf::RenderWindow& window);
-    void draw(sf::RenderWindow& window);
-    bool isWinCondition() const;
 
-    void setCursorVisibility(bool visible);
-    bool tryProcessDirection(const DIRECTION& direction);
+    // Output current graphical state on application window
+    void draw(sf::RenderWindow& window);
+
+    // Move cursor to next tile by given direction
     bool moveSelection(const DIRECTION& direction);
-    bool swapOnSelection(const DIRECTION& direction);
 
     // Go to or leave from selection mode
     void onSelectionMode();
 
+    // Did player win the game
+    bool isWinCondition() const;
+
+    // Show or hide selection cursos
+    void setCursorVisibility(bool visible = false);
+
 private:
 
+    // Game tile
     struct Cell
     {
         std::vector<Cell*>::size_type inital_index;
@@ -69,15 +76,4 @@ private:
 
     // Draw selection cursor on given tile
     void setSelectionVertex(Cells::size_type index);
-
-    void calculateBoardProperties(int splitting);
-
-    void splitImageIntoTiles(int tile_length);
-
-    void scaleImageToWindow(const sf::RenderWindow &window);
-    float calculateScalingToWindow(const sf::RenderWindow &window) const;
-    void scaleTiles(float scaling);
-    std::pair<float, float> calculateTileShiftVector(Cells::size_type tile_index, int shift) const;
-
-    void shuffleTiles();
 };

filepath_util.h

@@ -25,56 +25,7 @@ namespace filepath
         return std::equal(ending.rbegin(), ending.rend(), string.rbegin());
     }
 
-    std::string randomChoice(const std::vector<std::string>& poll)
-    {
-        std::cout << "Loading random image!\n";
-        const auto range = poll.size() - 1;
-        return poll.at(rand() & range);
-    }
-
-    std::vector<std::tuple<std::filesystem::path, std::filesystem::file_status>> extractFilesFrom(std::filesystem::path&& path)
-    {
-        std::vector<std::tuple<std::filesystem::path, std::filesystem::file_status>> dir_items;
-        std::transform(std::filesystem::directory_iterator(path), {}, std::back_inserter(dir_items), filepath::getFileInfo);
-        return dir_items;
-    }
-
-    bool isImage(const std::filesystem::path& filepath)
-    {
-        static std::set<std::string> allowed_ext = {".bmp", ".jpg", "*.jpeg", ".png"};
-        const std::string path_string = filepath.string();
-
-        return std::filesystem::is_regular_file(filepath) &&
-               std::any_of(allowed_ext.begin(), allowed_ext.end(),
-                           [&](const std::string& e)
-                           {
-                               return filepath::endsWith(path_string, e);
-                           });
-    }
-
-    std::tuple<int, std::vector<std::string>> parseFolder(std::filesystem::path&& path)
-    {
-        auto directory_items = extractFilesFrom(std::move(path));
-
-        std::vector<std::string> image_pathes;
-        for (const auto &[local_path, status] : directory_items)
-        {
-            if (isImage(local_path))
-                image_pathes.emplace_back(local_path.string());
-        }
-
-        if (image_pathes.empty())
-            return {EXIT_FAILURE, {}};
-
-        const std::tuple<int, std::vector<std::string>> empty_folder = {EXIT_FAILURE, {}};
-        const std::tuple<int, std::vector<std::string>> found_images = {EXIT_SUCCESS, image_pathes};
-
-        return image_pathes.empty()
-             ? empty_folder
-             : found_images;
-    }
-
-    std::tuple<int, std::vector<std::string>> parsePath(const std::string &argv)
+    std::tuple<int, std::string> parsePath(const std::string &argv)
     {
         std::filesystem::path path(argv);
         if (!std::filesystem::exists(path))
@@ -83,12 +34,38 @@ namespace filepath
             return {EXIT_FAILURE, {}};
         }
 
+        // Maybe user chose a specific image, not a folder
         if (std::filesystem::is_regular_file(path))
+            return {EXIT_SUCCESS, path.string()};
+                                                            // TO DO : I KNOW THIS PART IS BAD! I have never worked with ::filesystem before,
+        // So... it is a folder                                                            i will rewrite it when the prject works and is done
+        // Creating a vector of everything in the given directory
+        std::vector<std::tuple<std::filesystem::path, std::filesystem::file_status>> dir_items;
+        std::transform(std::filesystem::directory_iterator(path), {}, std::back_inserter(dir_items), filepath::getFileInfo);
+
+        std::set<std::string> allowed_ext = {".bmp", ".dds", ".jpg", ".png", ".tga", ".psd"};
+
+        // Now getting images
+        std::vector<std::string> dir_image_items;
+        for (const auto &[local_path, status] : dir_items)
         {
-            return {EXIT_SUCCESS, {path.string()}};
+            const std::string str_path = local_path.string();
+            if (std::filesystem::is_regular_file(local_path) &&
+                    std::any_of(allowed_ext.begin(), allowed_ext.end(), [&](const std::string& e) { return filepath::endsWith(str_path, e); }))
+            {
+                dir_image_items.emplace_back(str_path);
+            }
         }
 
-        return parseFolder(std::move(path));
+        if (dir_image_items.empty())
+        {
+            std::cout << "No images found at " << path << "\n--help for more information.\n";
+            return {EXIT_FAILURE, {}};
+        }
+
+        std::cout << "Loading random image file from " << path << "\n";
+        srand(static_cast<unsigned int>(time(nullptr)));
+        return {EXIT_SUCCESS, dir_image_items[rand() & (dir_image_items.size() - 1)]};
     }
 
     std::vector<std::string> split(const std::string &s, char delim)

main.cpp

@@ -1,16 +1,106 @@
 #include "application.h"
-#include "argsprocessor.h"
+#include "output_util.h"
+#include "filepath_util.h"
+#include <cstring>
+#include <cctype>
+
+/////////////////////////////////////////////////////////////////////////
+
+static constexpr int DEFAULT_SCREEN_WIDTH   = 1280;
+static constexpr int DEFAULT_SCREEN_HEIGHT  = 720;
+static constexpr int DEFAULT_SPLITTING = 4;
+static const std::string DEFAULT_PATH = "."; // current folder, I guess
+
+/////////////////////////////////////////////////////////////////////////
+
+std::tuple<int, int, sf::Vector2i, std::string> error(const char* msg)
+{
+    std::cout << msg;
+    return {EXIT_FAILURE, -1, {}, {}};
+}
+
+std::tuple<int, int, sf::Vector2i, std::string> parseInput(int argc, char **argv)
+{
+    int splitting = DEFAULT_SPLITTING;
+    sf::Vector2i resolution(DEFAULT_SCREEN_WIDTH, DEFAULT_SCREEN_HEIGHT);
+    std::string path = DEFAULT_PATH;
+
+    for (int current_arg = 1; current_arg < argc; ++current_arg) // current_arg = 0 is executable name
+    {
+        if (strcmp(argv[current_arg], output::HELP_FLAG) == 0) // --help
+            return error(output::HELP_MSG);
+
+        if (strcmp(argv[current_arg], output::SPLITTING_FLAG) == 0) // -s num
+        {
+            const int value_rg = current_arg + 1;
+            if (value_rg == argc) // is '-s' is the last argument
+                return error(output::SPLITTING_MSG);
+
+            splitting = -1; // here assuming user is providing it on their own
+            if (std::isdigit(*argv[value_rg]))
+                splitting = std::stoi(argv[value_rg]);
+
+            if (splitting < 2)
+                return error(output::SPLITTING_MSG);
+
+            ++current_arg; // skipping value after flag to not check it once again
+            continue;
+        }
+
+        if (strcmp(argv[current_arg], output::RESOLUTION_FLAG) == 0) // -r numxnum
+        {
+            const int value_rg = current_arg + 1;
+            if (value_rg == argc) // is '-s' is the last argument
+                return error(output::RESOLUTION_MSG);
+
+            std::vector<std::string> res = filepath::split(argv[value_rg], 'x');  // splitting argument by 'x' as in 600x900
+
+            if (res.size() < 2)
+                return error(output::RESOLUTION_MSG);
+
+            resolution = {-1, -1};
+
+            if (std::isdigit(*res[0].c_str()) && std::isdigit(*res[1].c_str()))
+                resolution = {std::stoi(res[0].c_str()), std::stoi(res[1].c_str())};
+
+            if (resolution.x < 1 || resolution.y < 1)
+                return error(output::RESOLUTION_MSG);
+
+            ++current_arg; // skipping value after flag to not check it once again
+            continue;
+        }
+
+        // nothing else, then assuming it's filepath or folderpath
+        const auto &[ret_code, ret_path] = filepath::parsePath(argv[current_arg]);
+
+        if (ret_code)
+            return error(output::IMG_FAIL_MSG);
+
+        path = ret_path;
+    }
+
+    if (path == DEFAULT_PATH)
+    {
+        // no path was give, loading random image from '.'
+        const auto &[ret_code, ret_path] = filepath::parsePath(path);
+
+        if (ret_code)
+            return error(output::IMG_FAIL_MSG);
+
+        path = ret_path;
+    }
+
+    return {EXIT_SUCCESS, splitting, resolution, path};
+}
+
+/////////////////////////////////////////////////////////////////////////
 
 int main(int argc, char **argv)
 {
-    srand(static_cast<unsigned int>(time(nullptr)));
+    const auto&[ret_code, splitting, resolution, path] = parseInput(argc, argv);
 
-    ArgsProcessor args(argc, argv);
-
-    if (args.broken())
-        return EXIT_FAILURE;
-
-    const auto&[splitting, resolution, path] = args.unpack();
+    if (ret_code) // Error code is EXIT_FAILURE
+        return ret_code;
 
     Application app(resolution.x, resolution.y);
     if (app.init(path, splitting))
@@ -18,6 +108,6 @@ int main(int argc, char **argv)
         app.run();
         return EXIT_SUCCESS;
     }
-    else
+
     return EXIT_FAILURE;
 }

output_util.h

@@ -8,14 +8,11 @@ namespace output
 
     const char* NO_ARG_MSG = "Please at least provide a path to a target image. --help for more information.\n";
     const char* HELP_MSG = "usage: sliding-puzzle [-OPTIONS...] FILE-OR-DIRECTORY\n\n"
-                       "    Provide FILE-OR-DIRECTORY variable as a path to either a directory\n"
-                       "    which contains images (one will be picked randomly) or a specific\n"
-                       "    image file of .bmp, .jpg, of .png format.\n\n"
-                       "    If no path was provided, it will be assumed as \'.\'!\n\n"
+                       "    Necessarily provide the latter variable as path to either a directory\n"
+                       "    which contains arts (one will be picked randomly) or a specific\n"
+                       "    image file of .bmp, .dds, .jpg, .png, .tga, or .psd format.\n\n"
                        "    Options:\n"
-                       "      [-r NUMxNUM] Provide it if you want to explicitly define\n"
-                       "                   window resolution.\n"
-                       "      [-s NUM]     Provide it if you want to explicitly define\n"
+                       "      [-s num]  Provide it if you want to explicitly define\n"
                        "                qualifier for image slicing, it's counted\n"
                        "                by the smallest side of given source texture.\n"
                        "                Hence, if your image is square, the amount of tiles\n"