zv0n/game
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Mario: formatting
Some checks failed
continuous-integration/drone/push Build is failing
Details

Browse Source
This commit is contained in:
zvon 2022-07-21 20:17:24 +02:00
parent 6558329547
commit 58fd1a37a8
9 changed files with 373 additions and 302 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
mario/filesystem/unix/filesystem.cpp
View File

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

3
mario/filesystem/windows/filesystem.cpp
View File

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

17
mario/gui/gui.hpp
View File

@ -33,8 +33,9 @@ public:
std::shared_ptr<SDLPP::Renderer> &r, const std::string &text, std::shared_ptr<SDLPP::Renderer> &r, const std::string &text,
const ButtonConfig &config, const ButtonConfig &config,
std::function<void(void *, Button *)> click_fun, void *input) 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), click_fun(std::move(click_fun)), func_input(input),
config(config), button_text(text) { config(config), button_text(text) {
setColor(config.bg_color); setColor(config.bg_color);
@ -150,13 +151,18 @@ public:
if (should_update_color) { if (should_update_color) {
switch (state) { switch (state) {
case NORMAL: 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; break;
case HIGHLIGHTED: 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; break;
case DISABLED: 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: default:
break; break;
} }
@ -165,6 +171,7 @@ public:
changeText(button_text); changeText(button_text);
} }
} }
private: private:
std::function<void(void *, Button *)> click_fun; std::function<void(void *, Button *)> click_fun;
void *func_input; void *func_input;

4
mario/maploader.cpp
View File

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

184
mario/scenes/editor_main.cpp
View File

@ -126,7 +126,8 @@ SceneStruct mainMenuScene;
std::shared_ptr<SDLPP::TextRenderer> global_test_text{}; std::shared_ptr<SDLPP::TextRenderer> global_test_text{};
std::string global_test_text_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) { void setFlag(uint64_t flag) {
global_vars.flags |= flag; global_vars.flags |= flag;
@ -249,7 +250,8 @@ void unsetToolColor() {
setToolColor("#FFFFFF00"); 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) { if (cur_page == 0) {
left->disable(); left->disable();
} else { } else {
@ -289,19 +291,26 @@ void updateToolSelection(int prev_index, ToolType::Value type) {
cur_page = global_vars.tool.cur_page_tools; cur_page = global_vars.tool.cur_page_tools;
multiplier = 2 * TOOLS_WIDTH; multiplier = 2 * TOOLS_WIDTH;
tool_vec = &global_vars.tools; 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; break;
case ToolType::MOD: case ToolType::MOD:
cur_page = global_vars.tool.cur_page_mods; cur_page = global_vars.tool.cur_page_mods;
multiplier = 2 * MOD_WIDTH; multiplier = 2 * MOD_WIDTH;
tool_vec = &global_vars.mods; 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; break;
case ToolType::CHARACTER: case ToolType::CHARACTER:
cur_page = global_vars.tool.cur_page_characters; cur_page = global_vars.tool.cur_page_characters;
multiplier = 2 * CHARACTER_WIDTH; multiplier = 2 * CHARACTER_WIDTH;
tool_vec = &global_vars.characters; 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: default:
break; break;
} }
@ -568,7 +577,8 @@ void getMousePositionFlags(SDLPP::Scene &scene) {
scene.visitCollisions(*mouse, visitor); scene.visitCollisions(*mouse, visitor);
if (visitor.getCurButton() != global_vars.mouse.cur_button_index) { if (visitor.getCurButton() != global_vars.mouse.cur_button_index) {
if (global_vars.mouse.cur_button_index != (uint64_t)-1) { 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) { if (visitor.getCurButton() != (uint64_t)-1) {
global_vars.buttons[visitor.getCurButton()]->setHighlight(); 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--; cur_page--;
toolMoveUpdateButtons(left, right, cur_page, max_page, canAdd); 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; cur_page += 1;
toolMoveUpdateButtons(left, right, cur_page, max_page, canAdd); 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) { void moveMapLeft(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); auto actual_input = static_cast<moveStruct *>(input);
actual_input->scene->moveEverything(BLOCK_SIZE, 0); 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) { 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.objects.resize(global_vars.objects.size() + 1);
global_vars.map.max_page++; 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); actual_input->scene->moveEverything(-BLOCK_SIZE, 0);
} }
void moveToolsLeftButton(void *input, Button *caller) { void moveToolsLeftButton(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); 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) { void moveToolsRightButton(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); 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) { void moveModsLeft(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); 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) { void moveModsRight(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); 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) { void moveCharsLeft(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); 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, updateToolSelection(global_vars.tool.cur_page_tools + 1,
ToolType::CHARACTER); ToolType::CHARACTER);
} }
void moveCharsRight(void *input, Button *caller) { void moveCharsRight(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); 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, updateToolSelection(global_vars.tool.cur_page_tools - 1,
ToolType::CHARACTER); ToolType::CHARACTER);
} }
void mouseUpAction(uint64_t flags) { void mouseUpAction(uint64_t flags) {
if (MouseVisitor::button(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)) { if (!getFlag(TEXT_INPUT_FLAG)) {
handleKeyUp(event.key.keysym.sym, *scene); handleKeyUp(event.key.keysym.sym, *scene);
} else { } 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(); SDL_StopTextInput();
unsetFlag(TEXT_INPUT_FLAG); unsetFlag(TEXT_INPUT_FLAG);
} }
@ -790,13 +814,16 @@ void pollEvents(std::shared_ptr<SDLPP::Scene> &scene) {
break; break;
case SDL_KEYDOWN: case SDL_KEYDOWN:
if (getFlag(TEXT_INPUT_FLAG)) { 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(); global_test_text_text.pop_back();
setFlag(TEXT_UPDATE_FLAG); 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 // handle copy
SDL_SetClipboardText(global_test_text_text.c_str()); 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 // handle paste
global_test_text_text += SDL_GetClipboardText(); global_test_text_text += SDL_GetClipboardText();
setFlag(TEXT_UPDATE_FLAG); setFlag(TEXT_UPDATE_FLAG);
@ -1003,7 +1030,8 @@ void testButtonFunc(void */*UNUSED*/, Button */*UNUSED*/) {
SDL_StartTextInput(); 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 renderer = scene->getRendererShared();
auto font = std::make_shared<SDLPP::Font>("testfont.ttf", 36); auto font = std::make_shared<SDLPP::Font>("testfont.ttf", 36);
auto font_config = std::make_shared<SDLPP::FontConfiguration>( 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()) { if (filename.empty()) {
loadEmptyMap(global_vars.objects, MAP_WIDTH); loadEmptyMap(global_vars.objects, MAP_WIDTH);
} else { } 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 // map
@ -1064,15 +1092,17 @@ void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene, const std::string &file
2, scene); 2, scene);
global_test_text = std::make_shared<SDLPP::TextRenderer>( 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->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_test_text->setPermanent(); global_test_text->setPermanent();
scene->addObject(global_test_text); scene->addObject(global_test_text);
global_vars.map.max_page = global_vars.objects.size() - MAP_WIDTH; global_vars.map.max_page = global_vars.objects.size() - MAP_WIDTH;
// arrowInputs[1] - rightMapInput, arrowInputs[0] - leftMapInput // 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 = auto mouse =
std::make_shared<SDLPP::RectangleRender>(0.01, 0.01, 0, 0, renderer); 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; 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); auto scene = std::make_shared<SDLPP::Scene>(renderer);
global_vars.tool.max_page_tools = 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>( global_vars.buttons.emplace_back(std::make_shared<Button>(
0, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE, 0, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE,
renderer, "<", default_button_theme, moveMapLeft, &left_map_input)); 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()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
// right map arrow // 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.scene = scene;
right_map_input.other_button = global_vars.buttons.back(); right_map_input.other_button = global_vars.buttons.back();
global_vars.buttons.emplace_back(std::make_shared<Button>( 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()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
left_map_input.other_button = global_vars.buttons.back(); left_map_input.other_button = global_vars.buttons.back();
// ensure disabled/enabled properly // 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 // left tool arrow
auto &left_tool_input = arrowInputs[2]; auto &left_tool_input = arrowInputs[2];
left_tool_input.scene = scene; left_tool_input.scene = scene;
left_tool_input.other_button = nullptr; left_tool_input.other_button = nullptr;
global_vars.buttons.emplace_back(std::make_shared<Button>( 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()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
global_vars.tool.button_left_tools = global_vars.buttons.back(); 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.scene = scene;
right_tool_input.other_button = global_vars.buttons.back(); right_tool_input.other_button = global_vars.buttons.back();
global_vars.buttons.emplace_back(std::make_shared<Button>( 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()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
left_tool_input.other_button = global_vars.buttons.back(); left_tool_input.other_button = global_vars.buttons.back();
global_vars.tool.button_right_tools = global_vars.buttons.back(); global_vars.tool.button_right_tools = global_vars.buttons.back();
// ensure disabled/enabled properly // 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 // left mod arrow
auto &left_mod_input = arrowInputs[4]; auto &left_mod_input = arrowInputs[4];
left_mod_input.scene = scene; left_mod_input.scene = scene;
left_mod_input.other_button = nullptr; left_mod_input.other_button = nullptr;
global_vars.buttons.emplace_back(std::make_shared<Button>( 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()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
global_vars.tool.button_left_mods = global_vars.buttons.back(); 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.scene = scene;
right_mod_input.other_button = global_vars.buttons.back(); right_mod_input.other_button = global_vars.buttons.back();
global_vars.buttons.emplace_back(std::make_shared<Button>( 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()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
left_mod_input.other_button = global_vars.buttons.back(); left_mod_input.other_button = global_vars.buttons.back();
global_vars.tool.button_right_mods = global_vars.buttons.back(); global_vars.tool.button_right_mods = global_vars.buttons.back();
// ensure disabled/enabled properly // 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 // left character arrow
auto &left_character_input = arrowInputs[6]; auto &left_character_input = arrowInputs[6];
left_character_input.scene = scene; left_character_input.scene = scene;
left_character_input.other_button = nullptr; left_character_input.other_button = nullptr;
global_vars.buttons.emplace_back(std::make_shared<Button>( 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()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
global_vars.tool.button_left_characters = global_vars.buttons.back(); 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.scene = scene;
right_character_input.other_button = global_vars.buttons.back(); right_character_input.other_button = global_vars.buttons.back();
global_vars.buttons.emplace_back(std::make_shared<Button>( 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()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
global_vars.tool.button_right_characters = global_vars.buttons.back(); global_vars.tool.button_right_characters = global_vars.buttons.back();
// ensure disabled/enabled properly // 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(); 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()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);

44
mario/scenes/editor_main_menu.cpp
View File

@ -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 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->setPermanent();
bg->setId(1); bg->setId(1);
scene->addObject(bg); scene->addObject(bg);
@ -80,27 +81,31 @@ std::shared_ptr<SDLPP::Scene> createSceneMainMenu(std::shared_ptr<SDLPP::Rendere
default_button_theme.outline = 0.1; default_button_theme.outline = 0.1;
// buttons // buttons
__buttons_main_menu.emplace_back(std::make_shared<Button>( __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()->setPermanent();
__buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1); __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
__buttons_main_menu.emplace_back(std::make_shared<Button>( __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()->setPermanent();
__buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1); __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
__buttons_main_menu.emplace_back(std::make_shared<Button>( __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()->setPermanent();
__buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1); __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
__buttons_main_menu.emplace_back(std::make_shared<Button>( __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()->setPermanent();
__buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1); __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
for (auto &button : __buttons_main_menu) { for (auto &button : __buttons_main_menu) {
@ -164,9 +169,11 @@ void pollEventsMainMenu(std::shared_ptr<SDLPP::Scene> &scene) {
getMousePositionFlagsMainMenu(*scene); getMousePositionFlagsMainMenu(*scene);
break; break;
case SDL_MOUSEBUTTONUP: 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) { __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; break;
case SDL_MOUSEBUTTONDOWN: 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{}; SceneStruct ret{};
ret.scene = createSceneMainMenu(renderer); ret.scene = createSceneMainMenu(renderer);
ret.additionalRender = additionalRenderMainMenu; ret.additionalRender = additionalRenderMainMenu;

6
mario/scenes/editor_scenes.hpp
View File

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