game/mario/scenes/load_scene.cpp

#include <utility>

#include "SDL2/SDL_keycode.h"
#include "editor_scenes.hpp"
#include "../../sdlpp/sdlpp.hpp"
#include "../../sdlpp/sdlpp_mouse.hpp"
#include "../global_vars.hpp"
#include "../objectids.hpp"
#include "../editor_visitor.hpp"
#include "../filesystem.hpp"
#include "../sprites.hpp"

bool __update_scenes_load_dialog = false;
bool __quit_scenes_load_dialog = false;
bool __started_load_dialog = false;
bool __pop_at_finish_load_dialog = false;
uint64_t __cur_button_index_load_dialog = -1;
uint64_t __cur_button_index_load_dialog_down = -1;
std::vector<std::shared_ptr<Button>> __buttons_load_dialog{};
std::shared_ptr<SDLPP::RectangleRender> __mouse_load_dialog{};

std::function<void(const std::string &)> __load_dialog_finalizer;
std::string __selected_level_load_dialog = "";

void __quitLoadDialog() {
    __quit_scenes_load_dialog = true;
}
void __updateSelectedButton_LoadDialog(uint64_t new_index) {
    if (new_index != __cur_button_index_load_dialog &&
        new_index != (uint64_t)-1) {
        __buttons_load_dialog[new_index]->setHighlight();

        if (__cur_button_index_load_dialog != (uint64_t)-1) {
            __buttons_load_dialog[__cur_button_index_load_dialog]
                ->unsetHighlight();
        }
        __cur_button_index_load_dialog = new_index;
    }
}

void __quitCallback_LoadDialog(void * /*UNUSED*/, Button *btn) {
    __selected_level_load_dialog = btn->getText();
    __quitLoadDialog();
}

void __moveButtons(double movement) {
    for (auto &button : __buttons_load_dialog) {
        button->setPos(button->getPos() + SDLPP::Vec2D<double>(0, movement));
    }
    __update_scenes_load_dialog = true;
}

void __selectUpperButton() {
    if (__cur_button_index_load_dialog > 0) {
        __updateSelectedButton_LoadDialog(__cur_button_index_load_dialog - 1);
        if (__buttons_load_dialog[__cur_button_index_load_dialog]
               ->getPos()
                .getY() < 0.49) {
            __moveButtons(0.25);
        }
    }
}

void __selectLowerButton() {
    if (__cur_button_index_load_dialog < __buttons_load_dialog.size() - 1) {
        __updateSelectedButton_LoadDialog(__cur_button_index_load_dialog + 1);
        auto pos =
            __buttons_load_dialog[__cur_button_index_load_dialog]->getPos();
        if (__buttons_load_dialog[__cur_button_index_load_dialog]
                ->getPos()
                .getY() > 0.99) {
            __moveButtons(-0.25);
        }
    }
}

void __handleKeyUp_LoadDialog(SDL_Keycode key, SDLPP::Scene & /*UNUSED*/) {
    switch (key) {
    case SDLK_ESCAPE:
        __selected_level_load_dialog = "";
        __quitLoadDialog();
        break;
    case SDLK_RETURN:
        __buttons_load_dialog[__cur_button_index_load_dialog]
            ->performFunction();
        break;
    case SDLK_UP:
    case SDLK_w:
        __selectUpperButton();
        break;
    case SDLK_DOWN:
    case SDLK_s:
        __selectLowerButton();
        break;
    default:
        break;
    }
}

void addLevelButton(const std::string &path, const std::string &file,
                    double &start_height, const int initial_path_len,
                    std::shared_ptr<SDLPP::Renderer> &renderer,
                    ButtonConfig &button_theme) {
    if (FSLib::isDirectory(path + FSLib::dir_divisor + file)) {
        for (const auto &file_rec :
             FSLib::Directory(path + FSLib::dir_divisor + file)) {
            addLevelButton(path + FSLib::dir_divisor + file, file_rec,
                           start_height, initial_path_len, renderer,
                           button_theme);
        }
    } else {
        __buttons_load_dialog.emplace_back(std::make_shared<Button>(
            0.3, start_height, 0.4, 0.2, renderer,
            (path + FSLib::dir_divisor + file).substr(initial_path_len),
            button_theme, __quitCallback_LoadDialog, nullptr));
        __buttons_load_dialog.back()->setAlignment(SDLPP::OBJ_CENTER,
                                                   SDLPP::OBJ_CENTER);
        __buttons_load_dialog.back()->setPermanent();
        __buttons_load_dialog.back()->setButtonIndex(
            __buttons_load_dialog.size() - 1);
        start_height += 0.25;
    }
}

std::shared_ptr<SDLPP::Scene>
createSceneLoadDialog(std::shared_ptr<SDLPP::Renderer> &renderer,
                      const std::string &path, bool transparent_bg) {
    auto scene = std::make_shared<SDLPP::Scene>(renderer);
    auto bg = std::make_shared<SDLPP::RectangleRender>(0, 0, 10, 10, renderer,
                                                       transparent_bg ? "#000000BB" : MARIO_OVERWORLD_COLORKEY, true);
    bg->setPermanent();
    bg->setId(1);
    scene->addObject(bg);
    __mouse_load_dialog =
        std::make_shared<SDLPP::RectangleRender>(0.01, 0.01, 0, 0, renderer);
    __mouse_load_dialog->setMinWidth(1);
    __mouse_load_dialog->setMinHeight(1);
    __mouse_load_dialog->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
    __mouse_load_dialog->setId(EDITOR_MOUSE_ID);
    __mouse_load_dialog->setColiderColor("#00FF00");
    __mouse_load_dialog->addCollision(SDLPP::RectColider({ 0, 0 }, { 1, 1 }));
    scene->addObject(__mouse_load_dialog);

    ButtonConfig default_button_theme{};
    default_button_theme.bg_color = "#FFFFFF88";
    default_button_theme.bg_color_highlight = "#FFFFFFBB";
    default_button_theme.bg_color_disabled = "#AAAAAA88";
    default_button_theme.font_color = "#000000";
    default_button_theme.font_color_highlight = "#000000";
    default_button_theme.font_color_disabled = "#555555";
    default_button_theme.font_outline_color = "#FFFFFF88";
    default_button_theme.font_outline_color_highlight = "#FFFFFFAA";
    default_button_theme.font_outline_color_disabled = "#787878";
    default_button_theme.outline = 0.1;
    // buttons
    double start_height = 0.5;
    for (const auto &file : FSLib::Directory(path)) {
        addLevelButton(path, file, start_height, path.length() + 1, renderer,
                       default_button_theme);
    }
    for (auto &button : __buttons_load_dialog) {
        scene->addObject(button);
    }
    auto font_config = std::make_shared<SDLPP::FontConfiguration>(
        g_text_config->getFont(), "#000000", "#FFFFFFAA", 0.05);
    auto dialog_text = std::make_shared<SDLPP::TextRenderer>(
        0.1, 0.15, 0.8, 0.3, renderer, "LEVELS", font_config,
        SDLPP_TEXT_CENTER);
    dialog_text->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
    dialog_text->setPermanent();
    scene->addObject(dialog_text);
    return scene;
}

void __resetGlobals_LoadDialog() {
    __update_scenes_load_dialog = false;
    __quit_scenes_load_dialog = false;
    __started_load_dialog = false;
    __pop_at_finish_load_dialog = false;
    __cur_button_index_load_dialog = -1;
    __cur_button_index_load_dialog_down = -1;
    __buttons_load_dialog.clear();
    __mouse_load_dialog.reset();
    __selected_level_load_dialog = "";
}

void __additionalRender_LoadDialog(std::shared_ptr<SDLPP::Scene> & /*UNUSED*/) {
    if (__update_scenes_load_dialog) {
        for (auto &_scene : game_scenes) {
            _scene.scene->updateSizeAndPosition();
        }
        if (__started_load_dialog) {
            __update_scenes_load_dialog = false;
        } else {
            __started_load_dialog = true;
        }
    }
    if (__quit_scenes_load_dialog) {
        __load_dialog_finalizer(__selected_level_load_dialog);
        if(__pop_at_finish_load_dialog) {
            game_scenes.pop_back();
        }
        __resetGlobals_LoadDialog();
    }
}

void __getMousePositionFlags_LoadDialog(SDLPP::Scene &scene) {
    auto mouse = scene.getObjects({ EDITOR_MOUSE_ID })[0];
    // move mouse colider to mouse position
    mouse->setPos(SDLPP::Mouse::getMousePositionDouble(
        scene.getRenderer(), SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER));

    MouseVisitor visitor;
    scene.visitCollisions(*mouse, visitor);
    __updateSelectedButton_LoadDialog(visitor.getCurButton());
    //__cur_button_index_load_dialog = visitor.getCurButton();
}

void __pollEvents_LoadDialog(std::shared_ptr<SDLPP::Scene> &scene) {
    SDL_Event event;
    while (SDLPP::getSDLEvent(event)) {
        switch (event.type) {
        case SDL_QUIT:
            __quitLoadDialog();
            break;
        case SDL_KEYUP:
            __handleKeyUp_LoadDialog(event.key.keysym.sym, *scene);
            break;
        case SDL_WINDOWEVENT:
            if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
                __update_scenes_load_dialog = true;
            }
            break;
        case SDL_MOUSEMOTION:
            __getMousePositionFlags_LoadDialog(*scene);
            break;
        case SDL_MOUSEBUTTONUP:
            if (__cur_button_index_load_dialog_down ==
                    __cur_button_index_load_dialog &&
                __cur_button_index_load_dialog != (uint64_t)-1) {
                __buttons_load_dialog[__cur_button_index_load_dialog]
                    ->performFunction();
            }
            break;
        case SDL_MOUSEBUTTONDOWN:
            // store current mouse flags in previous mouse flags
            __cur_button_index_load_dialog_down =
                __cur_button_index_load_dialog;
            break;
        case SDL_MOUSEWHEEL:
            if (event.wheel.y > 0) {
                __moveButtons(-0.02);
            } else if (event.wheel.y < 0) {
                __moveButtons(0.02);
            }
            break;
        default:
            break;
        }
    }
}

SceneStruct
createLoadScene(std::shared_ptr<SDLPP::Renderer> renderer,
                const std::string &path,
                std::function<void(const std::string &)> finalizer,
                bool pop_at_finish, bool transparent_bg) {
    __load_dialog_finalizer = std::move(finalizer);
    __pop_at_finish_load_dialog = pop_at_finish;
    SceneStruct ret{};
    ret.scene = createSceneLoadDialog(renderer, path, transparent_bg);
    ret.additionalRender = __additionalRender_LoadDialog;
    ret.doInput = __pollEvents_LoadDialog;
    __update_scenes_load_dialog = true;
    __updateSelectedButton_LoadDialog(0);
    return ret;
}