game/mario/scenes/load_scene.cpp

277 lines
9.9 KiB
C++
Raw Normal View History

2022-09-19 20:56:50 +00:00
#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;
2022-09-19 20:56:50 +00:00
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]
2022-09-19 20:56:50 +00:00
->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;
2022-09-19 20:56:50 +00:00
__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);
2022-09-19 20:56:50 +00:00
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,
2022-09-19 20:56:50 +00:00
std::function<void(const std::string &)> finalizer,
bool pop_at_finish, bool transparent_bg) {
2022-09-19 20:56:50 +00:00
__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;
}