Mario: formatting

mario/filesystem/unix/filesystem.cpp

@@ -15,16 +15,14 @@ FSLib::Directory::Directory( const string &path_ ) : dir_path( path_ ) {}
 FSLib::Directory::Iterator::Iterator(const Directory &d_)
         : d(opendir(d_.path())) {
     if (!exists(d_.path()) || !isDirectory(d_.path())) {
-        throw std::runtime_error(
+        throw std::runtime_error(std::string("Directory ") + d_.path() +
-            std::string( "Directory " ) + d_.path() +
                                  " either doesn't exist or isn't a directory");
     }
 
     current_entry = readdir(d);
 
     // skip "." and ".."
-    if ( current_entry != nullptr &&
+    if (current_entry != nullptr && (!strcmp(current_entry->d_name, ".") ||
-         ( !strcmp( current_entry->d_name, "." ) ||
                                      !strcmp(current_entry->d_name, "..")))
         ++(*this);
 }
@@ -138,8 +136,7 @@ FSLib::Directory::Iterator &FSLib::Directory::Iterator::operator++() {
         return *this;
     current_entry = readdir(d);
     // skip . and ..
-    if ( current_entry != nullptr &&
+    if (current_entry != nullptr && (!strcmp(current_entry->d_name, ".") ||
-         ( !strcmp( current_entry->d_name, "." ) ||
                                      !strcmp(current_entry->d_name, "..")))
         return operator++();
     return *this;

mario/filesystem/windows/filesystem.cpp

@@ -18,8 +18,7 @@ FSLib::Directory::Iterator::Iterator( const Directory &d_ ) {
     }
     hFind = FindFirstFileW(d_.path(), &data);
     if (hFind != INVALID_HANDLE_VALUE) {
-        if ( !wcscmp( data.cFileName, L"." ) ||
+        if (!wcscmp(data.cFileName, L".") || !wcscmp(data.cFileName, L"..")) {
-             !wcscmp( data.cFileName, L".." ) ) {
             ++(*this);
         }
     } else {

mario/gui/gui.cpp

@@ -1,12 +0,0 @@
-#include "gui.hpp"
-
-/*std::shared_ptr<SDLPP::RectangleRender>
-createButton(double x, double y, double w, double h,
-             std::shared_ptr<SDLPP::Renderer> &r, const std::string &text,
-             const std::string &color, const std::string &outline_color,
-             const std::string &background_color,
-             std::function<void(void *)> click_fun, void *input) {
-    auto button = std::make_shared<Button>(
-        x, y, w, h, r, text, color, outline_color, background_color, click_fun, input);
-    return std::static_pointer_cast<SDLPP::RectangleRender>(button);
-}*/

mario/gui/gui.hpp

@@ -33,8 +33,9 @@ public:
            std::shared_ptr<SDLPP::Renderer> &r, const std::string &text,
            const ButtonConfig &config,
            std::function<void(void *, Button *)> click_fun, void *input)
-            : TextRenderer(x, y, w, h, r, g_text_config->getFont(), text, config.font_color,
+            : TextRenderer(x, y, w, h, r, g_text_config->getFont(), text,
-                           config.font_outline_color, config.outline),
+                           config.font_color, config.font_outline_color,
+                           config.outline),
               click_fun(std::move(click_fun)), func_input(input),
               config(config), button_text(text) {
         setColor(config.bg_color);
@@ -150,13 +151,18 @@ public:
         if (should_update_color) {
             switch (state) {
             case NORMAL:
-                    setTextColor(g_text_config->getFont(), config.font_color, config.font_outline_color, config.outline);
+                setTextColor(g_text_config->getFont(), config.font_color,
+                             config.font_outline_color, config.outline);
                 break;
             case HIGHLIGHTED:
-                    setTextColor(g_text_config->getFont(), config.font_color_highlight, config.font_outline_color_highlight, config.outline);
+                setTextColor(
+                    g_text_config->getFont(), config.font_color_highlight,
+                    config.font_outline_color_highlight, config.outline);
                 break;
             case DISABLED:
-                    setTextColor(g_text_config->getFont(), config.font_color_disabled, config.font_outline_color_disabled, config.outline);
+                setTextColor(
+                    g_text_config->getFont(), config.font_color_disabled,
+                    config.font_outline_color_disabled, config.outline);
             default:
                 break;
             }
@@ -165,6 +171,7 @@ public:
             changeText(button_text);
         }
     }
+
 private:
     std::function<void(void *, Button *)> click_fun;
     void *func_input;

mario/maploader.cpp

@@ -118,7 +118,8 @@ void loadMap(std::shared_ptr<SDLPP::Scene> &scene,
     map_file.read((char *)&version, sizeof(uint16_t) / sizeof(char));
     switch (version) {
     case 0x01:
-            loadMapV01(scene, mario, map_file, objects, editor, editor_width, renderer);
+        loadMapV01(scene, mario, map_file, objects, editor, editor_width,
+                   renderer);
         break;
     default:
         throw "Invalid file version";
@@ -222,7 +223,6 @@ void loadMapV01(std::shared_ptr<SDLPP::Scene> &scene,
     if (editor && objects.size() < editor_width) {
         objects.resize(editor_width);
     }
-
 }
 
 // TODO catch exception in calling func

mario/scenes/editor_main.cpp

@@ -126,7 +126,8 @@ SceneStruct mainMenuScene;
 std::shared_ptr<SDLPP::TextRenderer> global_test_text{};
 std::string global_test_text_text{};
 
-void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene, const std::string &filename);
+void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene,
+                   const std::string &filename);
 
 void setFlag(uint64_t flag) {
     global_vars.flags |= flag;
@@ -249,7 +250,8 @@ void unsetToolColor() {
     setToolColor("#FFFFFF00");
 }
 
-void toolMoveUpdateButtons(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
+void toolMoveUpdateButtons(Button *left, Button *right, int &cur_page,
+                           int &max_page, bool canAdd) {
     if (cur_page == 0) {
         left->disable();
     } else {
@@ -289,19 +291,26 @@ void updateToolSelection(int prev_index, ToolType::Value type) {
         cur_page = global_vars.tool.cur_page_tools;
         multiplier = 2 * TOOLS_WIDTH;
         tool_vec = &global_vars.tools;
-        toolMoveUpdateButtons(global_vars.tool.button_left_tools.get(), global_vars.tool.button_right_tools.get(), cur_page, global_vars.tool.max_page_tools, false);
+        toolMoveUpdateButtons(global_vars.tool.button_left_tools.get(),
+                              global_vars.tool.button_right_tools.get(),
+                              cur_page, global_vars.tool.max_page_tools, false);
         break;
     case ToolType::MOD:
         cur_page = global_vars.tool.cur_page_mods;
         multiplier = 2 * MOD_WIDTH;
         tool_vec = &global_vars.mods;
-        toolMoveUpdateButtons(global_vars.tool.button_left_mods.get(), global_vars.tool.button_right_mods.get(), cur_page, global_vars.tool.max_page_mods, false);
+        toolMoveUpdateButtons(global_vars.tool.button_left_mods.get(),
+                              global_vars.tool.button_right_mods.get(),
+                              cur_page, global_vars.tool.max_page_mods, false);
         break;
     case ToolType::CHARACTER:
         cur_page = global_vars.tool.cur_page_characters;
         multiplier = 2 * CHARACTER_WIDTH;
         tool_vec = &global_vars.characters;
-        toolMoveUpdateButtons(global_vars.tool.button_left_characters.get(), global_vars.tool.button_right_characters.get(), cur_page, global_vars.tool.max_page_characters, false);
+        toolMoveUpdateButtons(global_vars.tool.button_left_characters.get(),
+                              global_vars.tool.button_right_characters.get(),
+                              cur_page, global_vars.tool.max_page_characters,
+                              false);
     default:
         break;
     }
@@ -568,7 +577,8 @@ void getMousePositionFlags(SDLPP::Scene &scene) {
     scene.visitCollisions(*mouse, visitor);
     if (visitor.getCurButton() != global_vars.mouse.cur_button_index) {
         if (global_vars.mouse.cur_button_index != (uint64_t)-1) {
-            global_vars.buttons[global_vars.mouse.cur_button_index]->unsetHighlight();
+            global_vars.buttons[global_vars.mouse.cur_button_index]
+                ->unsetHighlight();
         }
         if (visitor.getCurButton() != (uint64_t)-1) {
             global_vars.buttons[visitor.getCurButton()]->setHighlight();
@@ -591,11 +601,13 @@ void getMousePositionFlags(SDLPP::Scene &scene) {
     }
 }
 
-void toolMoveLeft(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
+void toolMoveLeft(Button *left, Button *right, int &cur_page, int &max_page,
+                  bool canAdd) {
     cur_page--;
     toolMoveUpdateButtons(left, right, cur_page, max_page, canAdd);
 }
-void toolMoveRight(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
+void toolMoveRight(Button *left, Button *right, int &cur_page, int &max_page,
+                   bool canAdd) {
     cur_page += 1;
     toolMoveUpdateButtons(left, right, cur_page, max_page, canAdd);
 }
@@ -603,7 +615,8 @@ void toolMoveRight(Button *left, Button *right, int &cur_page, int &max_page, bo
 void moveMapLeft(void *input, Button *caller) {
     auto actual_input = static_cast<moveStruct *>(input);
     actual_input->scene->moveEverything(BLOCK_SIZE, 0);
-    toolMoveLeft(caller, actual_input->other_button.get(), global_vars.map.cur_page, global_vars.map.max_page, true);
+    toolMoveLeft(caller, actual_input->other_button.get(),
+                 global_vars.map.cur_page, global_vars.map.max_page, true);
 }
 
 void moveMapRight(void *input, Button *caller) {
@@ -612,55 +625,65 @@ void moveMapRight(void *input, Button *caller) {
         global_vars.objects.resize(global_vars.objects.size() + 1);
         global_vars.map.max_page++;
     }
-    toolMoveRight(actual_input->other_button.get(), caller, global_vars.map.cur_page, global_vars.map.max_page, true);
+    toolMoveRight(actual_input->other_button.get(), caller,
+                  global_vars.map.cur_page, global_vars.map.max_page, true);
     actual_input->scene->moveEverything(-BLOCK_SIZE, 0);
 }
 
 void moveToolsLeftButton(void *input, Button *caller) {
     auto actual_input = static_cast<moveStruct *>(input);
-    toolMoveLeft(caller, actual_input->other_button.get(), global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
+    toolMoveLeft(caller, actual_input->other_button.get(),
-    updateToolSelection(global_vars.tool.cur_page_tools + 1,
+                 global_vars.tool.cur_page_tools,
-                        ToolType::BLOCK);
+                 global_vars.tool.max_page_tools, false);
+    updateToolSelection(global_vars.tool.cur_page_tools + 1, ToolType::BLOCK);
 }
 
 void moveToolsRightButton(void *input, Button *caller) {
     auto actual_input = static_cast<moveStruct *>(input);
-    toolMoveRight(actual_input->other_button.get(), caller, global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
+    toolMoveRight(actual_input->other_button.get(), caller,
-    updateToolSelection(global_vars.tool.cur_page_tools - 1,
+                  global_vars.tool.cur_page_tools,
-                        ToolType::BLOCK);
+                  global_vars.tool.max_page_tools, false);
+    updateToolSelection(global_vars.tool.cur_page_tools - 1, ToolType::BLOCK);
 }
 
 void moveModsLeft(void *input, Button *caller) {
     auto actual_input = static_cast<moveStruct *>(input);
-    toolMoveLeft(caller, actual_input->other_button.get(), global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
+    toolMoveLeft(caller, actual_input->other_button.get(),
-    updateToolSelection(global_vars.tool.cur_page_tools + 1,
+                 global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods,
-                        ToolType::MOD);
+                 false);
+    updateToolSelection(global_vars.tool.cur_page_tools + 1, ToolType::MOD);
 }
 
 void moveModsRight(void *input, Button *caller) {
     auto actual_input = static_cast<moveStruct *>(input);
-    toolMoveRight(actual_input->other_button.get(), caller, global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
+    toolMoveRight(actual_input->other_button.get(), caller,
-    updateToolSelection(global_vars.tool.cur_page_tools - 1,
+                  global_vars.tool.cur_page_mods,
-                        ToolType::MOD);
+                  global_vars.tool.max_page_mods, false);
+    updateToolSelection(global_vars.tool.cur_page_tools - 1, ToolType::MOD);
 }
 
 void moveCharsLeft(void *input, Button *caller) {
     auto actual_input = static_cast<moveStruct *>(input);
-    toolMoveLeft(caller, actual_input->other_button.get(), global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
+    toolMoveLeft(caller, actual_input->other_button.get(),
+                 global_vars.tool.cur_page_characters,
+                 global_vars.tool.max_page_characters, false);
     updateToolSelection(global_vars.tool.cur_page_tools + 1,
                         ToolType::CHARACTER);
 }
 
 void moveCharsRight(void *input, Button *caller) {
     auto actual_input = static_cast<moveStruct *>(input);
-    toolMoveRight(actual_input->other_button.get(), caller, global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
+    toolMoveRight(actual_input->other_button.get(), caller,
+                  global_vars.tool.cur_page_characters,
+                  global_vars.tool.max_page_characters, false);
     updateToolSelection(global_vars.tool.cur_page_tools - 1,
                         ToolType::CHARACTER);
 }
 
 void mouseUpAction(uint64_t flags) {
     if (MouseVisitor::button(flags)) {
-        global_vars.buttons[global_vars.mouse.cur_button_index]->performFunction();
+        global_vars.buttons[global_vars.mouse.cur_button_index]
+            ->performFunction();
     }
 }
 
@@ -782,7 +805,8 @@ void pollEvents(std::shared_ptr<SDLPP::Scene> &scene) {
             if (!getFlag(TEXT_INPUT_FLAG)) {
                 handleKeyUp(event.key.keysym.sym, *scene);
             } else {
-                if ( event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_RETURN ) {
+                if (event.key.keysym.sym == SDLK_ESCAPE ||
+                    event.key.keysym.sym == SDLK_RETURN) {
                     SDL_StopTextInput();
                     unsetFlag(TEXT_INPUT_FLAG);
                 }
@@ -790,13 +814,16 @@ void pollEvents(std::shared_ptr<SDLPP::Scene> &scene) {
             break;
         case SDL_KEYDOWN:
             if (getFlag(TEXT_INPUT_FLAG)) {
-                if( event.key.keysym.sym == SDLK_BACKSPACE && !global_test_text_text.empty() ) {
+                if (event.key.keysym.sym == SDLK_BACKSPACE &&
+                    !global_test_text_text.empty()) {
                     global_test_text_text.pop_back();
                     setFlag(TEXT_UPDATE_FLAG);
-                } else if( event.key.keysym.sym == SDLK_c && SDL_GetModState() & KMOD_CTRL ) {
+                } else if (event.key.keysym.sym == SDLK_c &&
+                           SDL_GetModState() & KMOD_CTRL) {
                     // handle copy
                     SDL_SetClipboardText(global_test_text_text.c_str());
-                } else if( event.key.keysym.sym == SDLK_v && SDL_GetModState() & KMOD_CTRL ) {
+                } else if (event.key.keysym.sym == SDLK_v &&
+                           SDL_GetModState() & KMOD_CTRL) {
                     // handle paste
                     global_test_text_text += SDL_GetClipboardText();
                     setFlag(TEXT_UPDATE_FLAG);
@@ -1003,7 +1030,8 @@ void testButtonFunc(void */*UNUSED*/, Button */*UNUSED*/) {
     SDL_StartTextInput();
 }
 
-void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene, const std::string &filename) {
+void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene,
+                   const std::string &filename) {
     auto renderer = scene->getRendererShared();
     auto font = std::make_shared<SDLPP::Font>("testfont.ttf", 36);
     auto font_config = std::make_shared<SDLPP::FontConfiguration>(
@@ -1019,8 +1047,8 @@ void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene, const std::string &file
     if (filename.empty()) {
         loadEmptyMap(global_vars.objects, MAP_WIDTH);
     } else {
-        loadMap(scene, global_vars.mario, "test_binary.bin", global_vars.objects,
+        loadMap(scene, global_vars.mario, "test_binary.bin",
-                true, MAP_WIDTH);
+                global_vars.objects, true, MAP_WIDTH);
     }
 
     // map
@@ -1064,15 +1092,17 @@ void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene, const std::string &file
                2, scene);
 
     global_test_text = std::make_shared<SDLPP::TextRenderer>(
-        0.3, 0.05, BLOCK_SIZE*4, BLOCK_SIZE*2,
+        0.3, 0.05, BLOCK_SIZE * 4, BLOCK_SIZE * 2, renderer, "TEST TEXT",
-        renderer, "TEST TEXT", font_config, SDLPP_TEXT_CENTER);
+        font_config, SDLPP_TEXT_CENTER);
     global_test_text->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
     global_test_text->setPermanent();
     scene->addObject(global_test_text);
 
     global_vars.map.max_page = global_vars.objects.size() - MAP_WIDTH;
     // arrowInputs[1] - rightMapInput, arrowInputs[0] - leftMapInput
-    toolMoveUpdateButtons(arrowInputs[1].other_button.get(), arrowInputs[0].other_button.get(), global_vars.map.cur_page, global_vars.map.max_page, true);
+    toolMoveUpdateButtons(
+        arrowInputs[1].other_button.get(), arrowInputs[0].other_button.get(),
+        global_vars.map.cur_page, global_vars.map.max_page, true);
 
     auto mouse =
         std::make_shared<SDLPP::RectangleRender>(0.01, 0.01, 0, 0, renderer);
@@ -1129,7 +1159,8 @@ void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene, const std::string &file
     global_vars.tool.cur_page_characters = 0;
 }
 
-std::shared_ptr<SDLPP::Scene> createEditorMainScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
+std::shared_ptr<SDLPP::Scene>
+createEditorMainScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
     auto scene = std::make_shared<SDLPP::Scene>(renderer);
 
     global_vars.tool.max_page_tools =
@@ -1160,7 +1191,8 @@ std::shared_ptr<SDLPP::Scene> createEditorMainScene(std::shared_ptr<SDLPP::Rende
     global_vars.buttons.emplace_back(std::make_shared<Button>(
         0, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE,
         renderer, "<", default_button_theme, moveMapLeft, &left_map_input));
-    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
+                                             SDLPP::OBJ_CENTER);
     global_vars.buttons.back()->setPermanent();
     global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
     // right map arrow
@@ -1168,23 +1200,29 @@ std::shared_ptr<SDLPP::Scene> createEditorMainScene(std::shared_ptr<SDLPP::Rende
     right_map_input.scene = scene;
     right_map_input.other_button = global_vars.buttons.back();
     global_vars.buttons.emplace_back(std::make_shared<Button>(
-        (MAP_WIDTH + 1) * BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE,
+        (MAP_WIDTH + 1) * BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE,
-        renderer, ">", default_button_theme, moveMapRight, &right_map_input));
+        MAP_HEIGHT * BLOCK_SIZE, renderer, ">", default_button_theme,
-    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+        moveMapRight, &right_map_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
+                                             SDLPP::OBJ_CENTER);
     global_vars.buttons.back()->setPermanent();
     global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
     left_map_input.other_button = global_vars.buttons.back();
     // ensure disabled/enabled properly
-    toolMoveUpdateButtons(right_map_input.other_button.get(), global_vars.buttons.back().get(), global_vars.map.cur_page, global_vars.map.max_page, true);
+    toolMoveUpdateButtons(
+        right_map_input.other_button.get(), global_vars.buttons.back().get(),
+        global_vars.map.cur_page, global_vars.map.max_page, true);
 
     // left tool arrow
     auto &left_tool_input = arrowInputs[2];
     left_tool_input.scene = scene;
     left_tool_input.other_button = nullptr;
     global_vars.buttons.emplace_back(std::make_shared<Button>(
-        (MAP_WIDTH - TOOLS_WIDTH - 1) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
+        (MAP_WIDTH - TOOLS_WIDTH - 1) * BLOCK_SIZE,
-        renderer, "<", default_button_theme, moveToolsLeftButton, &left_tool_input));
+        1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, renderer,
-    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+        "<", default_button_theme, moveToolsLeftButton, &left_tool_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
+                                             SDLPP::OBJ_CENTER);
     global_vars.buttons.back()->setPermanent();
     global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
     global_vars.tool.button_left_tools = global_vars.buttons.back();
@@ -1193,24 +1231,31 @@ std::shared_ptr<SDLPP::Scene> createEditorMainScene(std::shared_ptr<SDLPP::Rende
     right_tool_input.scene = scene;
     right_tool_input.other_button = global_vars.buttons.back();
     global_vars.buttons.emplace_back(std::make_shared<Button>(
-        MAP_WIDTH * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
+        MAP_WIDTH * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE,
-        renderer, ">", default_button_theme, moveToolsRightButton, &right_tool_input));
+        2 * BLOCK_SIZE, renderer, ">", default_button_theme,
-    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+        moveToolsRightButton, &right_tool_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
+                                             SDLPP::OBJ_CENTER);
     global_vars.buttons.back()->setPermanent();
     global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
     left_tool_input.other_button = global_vars.buttons.back();
     global_vars.tool.button_right_tools = global_vars.buttons.back();
     // ensure disabled/enabled properly
-    toolMoveUpdateButtons(right_tool_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
+    toolMoveUpdateButtons(right_tool_input.other_button.get(),
+                          global_vars.buttons.back().get(),
+                          global_vars.tool.cur_page_tools,
+                          global_vars.tool.max_page_tools, false);
 
     // left mod arrow
     auto &left_mod_input = arrowInputs[4];
     left_mod_input.scene = scene;
     left_mod_input.other_button = nullptr;
     global_vars.buttons.emplace_back(std::make_shared<Button>(
-        4 * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
+        4 * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE,
-        renderer, "<", default_button_theme, moveModsLeft, &left_mod_input));
+        2 * BLOCK_SIZE, renderer, "<", default_button_theme, moveModsLeft,
-    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+        &left_mod_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
+                                             SDLPP::OBJ_CENTER);
     global_vars.buttons.back()->setPermanent();
     global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
     global_vars.tool.button_left_mods = global_vars.buttons.back();
@@ -1219,24 +1264,30 @@ std::shared_ptr<SDLPP::Scene> createEditorMainScene(std::shared_ptr<SDLPP::Rende
     right_mod_input.scene = scene;
     right_mod_input.other_button = global_vars.buttons.back();
     global_vars.buttons.emplace_back(std::make_shared<Button>(
-        (MOD_WIDTH + 5) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
+        (MOD_WIDTH + 5) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE,
-        renderer, ">", default_button_theme, moveModsRight, &right_mod_input));
+        BLOCK_SIZE, 2 * BLOCK_SIZE, renderer, ">", default_button_theme,
-    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+        moveModsRight, &right_mod_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
+                                             SDLPP::OBJ_CENTER);
     global_vars.buttons.back()->setPermanent();
     global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
     left_mod_input.other_button = global_vars.buttons.back();
     global_vars.tool.button_right_mods = global_vars.buttons.back();
     // ensure disabled/enabled properly
-    toolMoveUpdateButtons(right_mod_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
+    toolMoveUpdateButtons(
+        right_mod_input.other_button.get(), global_vars.buttons.back().get(),
+        global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
 
     // left character arrow
     auto &left_character_input = arrowInputs[6];
     left_character_input.scene = scene;
     left_character_input.other_button = nullptr;
     global_vars.buttons.emplace_back(std::make_shared<Button>(
-        (MOD_WIDTH + 7) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
+        (MOD_WIDTH + 7) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE,
-        renderer, "<", default_button_theme, moveCharsLeft, &left_character_input));
+        BLOCK_SIZE, 2 * BLOCK_SIZE, renderer, "<", default_button_theme,
-    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+        moveCharsLeft, &left_character_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
+                                             SDLPP::OBJ_CENTER);
     global_vars.buttons.back()->setPermanent();
     global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
     global_vars.tool.button_left_characters = global_vars.buttons.back();
@@ -1245,17 +1296,24 @@ std::shared_ptr<SDLPP::Scene> createEditorMainScene(std::shared_ptr<SDLPP::Rende
     right_character_input.scene = scene;
     right_character_input.other_button = global_vars.buttons.back();
     global_vars.buttons.emplace_back(std::make_shared<Button>(
-        (MOD_WIDTH + 8 + CHARACTER_WIDTH) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
+        (MOD_WIDTH + 8 + CHARACTER_WIDTH) * BLOCK_SIZE,
-        renderer, ">", default_button_theme, moveCharsRight, &right_character_input));
+        1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, renderer,
-    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+        ">", default_button_theme, moveCharsRight, &right_character_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
+                                             SDLPP::OBJ_CENTER);
     global_vars.buttons.back()->setPermanent();
     global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
     global_vars.tool.button_right_characters = global_vars.buttons.back();
     // ensure disabled/enabled properly
-    toolMoveUpdateButtons(right_character_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
+    toolMoveUpdateButtons(right_character_input.other_button.get(),
+                          global_vars.buttons.back().get(),
+                          global_vars.tool.cur_page_characters,
+                          global_vars.tool.max_page_characters, false);
     left_character_input.other_button = global_vars.buttons.back();
 
-    global_vars.buttons.emplace_back(std::make_shared<Button>(0, 0, 0.2, 0.2, renderer, "Write Button", default_button_theme, testButtonFunc, nullptr));
+    global_vars.buttons.emplace_back(std::make_shared<Button>(
+        0, 0, 0.2, 0.2, renderer, "Write Button", default_button_theme,
+        testButtonFunc, nullptr));
     global_vars.buttons.back()->setPermanent();
     global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
 

mario/scenes/editor_main_menu.cpp

@@ -50,10 +50,11 @@ void handleKeyUpMainMenu(SDL_Keycode key, SDLPP::Scene &/*UNUSED*/) {
     }
 }
 
-std::shared_ptr<SDLPP::Scene> createSceneMainMenu(std::shared_ptr<SDLPP::Renderer> &renderer) {
+std::shared_ptr<SDLPP::Scene>
+createSceneMainMenu(std::shared_ptr<SDLPP::Renderer> &renderer) {
     auto scene = std::make_shared<SDLPP::Scene>(renderer);
-    auto bg = std::make_shared<SDLPP::RectangleRender>(
+    auto bg = std::make_shared<SDLPP::RectangleRender>(0, 0, 10, 10, renderer,
-        0, 0, 10, 10, renderer, "#00000088", true);
+                                                       "#00000088", true);
     bg->setPermanent();
     bg->setId(1);
     scene->addObject(bg);
@@ -80,27 +81,31 @@ std::shared_ptr<SDLPP::Scene> createSceneMainMenu(std::shared_ptr<SDLPP::Rendere
     default_button_theme.outline = 0.1;
     // buttons
     __buttons_main_menu.emplace_back(std::make_shared<Button>(
-        0.2, 0.25, 0.6, 0.1,
+        0.2, 0.25, 0.6, 0.1, renderer, "SAVE", default_button_theme,
-        renderer, "SAVE", default_button_theme, saveMapCallback, nullptr));
+        saveMapCallback, nullptr));
-    __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
+                                             SDLPP::OBJ_CENTER);
     __buttons_main_menu.back()->setPermanent();
     __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
     __buttons_main_menu.emplace_back(std::make_shared<Button>(
-        0.2, 0.4, 0.6, 0.1,
+        0.2, 0.4, 0.6, 0.1, renderer, "LOAD", default_button_theme,
-        renderer, "LOAD", default_button_theme, loadMapDialogCallback, nullptr));
+        loadMapDialogCallback, nullptr));
-    __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
+                                             SDLPP::OBJ_CENTER);
     __buttons_main_menu.back()->setPermanent();
     __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
     __buttons_main_menu.emplace_back(std::make_shared<Button>(
-        0.2, 0.55, 0.6, 0.1,
+        0.2, 0.55, 0.6, 0.1, renderer, "RESUME", default_button_theme,
-        renderer, "RESUME", default_button_theme, resumeMainMenuCallback, nullptr));
+        resumeMainMenuCallback, nullptr));
-    __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
+                                             SDLPP::OBJ_CENTER);
     __buttons_main_menu.back()->setPermanent();
     __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
     __buttons_main_menu.emplace_back(std::make_shared<Button>(
-        0.2, 0.7, 0.6, 0.1,
+        0.2, 0.7, 0.6, 0.1, renderer, "QUIT", default_button_theme,
-        renderer, "QUIT", default_button_theme, quitMainMenuCallback, nullptr));
+        quitMainMenuCallback, nullptr));
-    __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
+                                             SDLPP::OBJ_CENTER);
     __buttons_main_menu.back()->setPermanent();
     __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
     for (auto &button : __buttons_main_menu) {
@@ -164,9 +169,11 @@ void pollEventsMainMenu(std::shared_ptr<SDLPP::Scene> &scene) {
             getMousePositionFlagsMainMenu(*scene);
             break;
         case SDL_MOUSEBUTTONUP:
-            if (__cur_button_index_main_menu_down == __cur_button_index_main_menu &&
+            if (__cur_button_index_main_menu_down ==
+                    __cur_button_index_main_menu &&
                 __cur_button_index_main_menu != (uint64_t)-1) {
-                __buttons_main_menu[__cur_button_index_main_menu]->performFunction();
+                __buttons_main_menu[__cur_button_index_main_menu]
+                    ->performFunction();
             }
             break;
         case SDL_MOUSEBUTTONDOWN:
@@ -179,7 +186,8 @@ void pollEventsMainMenu(std::shared_ptr<SDLPP::Scene> &scene) {
     }
 }
 
-SceneStruct createEditorMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
+SceneStruct
+createEditorMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
     SceneStruct ret{};
     ret.scene = createSceneMainMenu(renderer);
     ret.additionalRender = additionalRenderMainMenu;

mario/scenes/editor_scenes.hpp

@@ -18,7 +18,9 @@ void saveMapCallback(void *input, Button *caller);
 void loadMapDialogCallback(void *input, Button *caller);
 
 SceneStruct createEditorScene(std::shared_ptr<SDLPP::Renderer> &renderer);
-SceneStruct createEditorMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer);
+SceneStruct
-SceneStruct createEditorFileChoiceScene(std::shared_ptr<SDLPP::Renderer> &renderer);
+createEditorMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer);
+SceneStruct
+createEditorFileChoiceScene(std::shared_ptr<SDLPP::Renderer> &renderer);
 
 #endif

mario/testmap.txt

@@ -1,20 +0,0 @@
-35
-16
-15
-13
-F                                  
-F                                  
-F                      zxc         
-F                      asd         
-F                                  
-F                                  
-F                                  
-F                                  
-F                                   
-F                                   
-F                                  
-F                T                 
-F               IRD                
-F              IRGLD      qwwwr    
-FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
-FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF