From b54ba5034c6a11c7ec4a8b7df3a9bec9ae9e536e Mon Sep 17 00:00:00 2001 From: zv0n Date: Sun, 9 May 2021 00:43:53 +0200 Subject: [PATCH] Mario editor: started refactoring --- mario/blocks.cpp | 34 ++- mario/blocks.hpp | 35 ++- mario/editor.cpp | 466 +++++++++++++++++++++++---------------- mario/editor_visitor.cpp | 4 +- mario/editor_visitor.hpp | 11 +- mario/maploader.cpp | 10 +- mario/maploader.hpp | 18 +- mario/objectids.hpp | 2 - 8 files changed, 353 insertions(+), 227 deletions(-) diff --git a/mario/blocks.cpp b/mario/blocks.cpp index 39ddac2..93340c4 100644 --- a/mario/blocks.cpp +++ b/mario/blocks.cpp @@ -2,14 +2,15 @@ #include "global_vars.hpp" #include "objectids.hpp" #include "sprites.hpp" +#include "editor_visitor.hpp" #include MarioBlock::MarioBlock(int x, int y, std::shared_ptr renderer, std::shared_ptr texture, SDL_Rect src) : RectangleRender( x * BLOCK_SIZE, 1 - (16-y) * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer, texture, src ) {} void MarioBlock::visit( SDLPP::Visitor &visitor ) { - if(!_tool && _terrain && visitor.getVisitorType() == TOOL_VISITOR_TYPE) { + if(!_tool && _terrain && visitor.getVisitorType() == VisitorType::Terrain) { destroy(); } - if(!_tool && !_terrain && visitor.getVisitorType() == MODIFIER_VISITOR_TYPE) { + if(!_tool && !_terrain && visitor.getVisitorType() == VisitorType::Modifier) { destroy(); } visitor.visit(*this); @@ -137,56 +138,65 @@ createBlock( std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y, return block; } -SDL_Rect getSourceRectByID( uint64_t id, BlockType type ) { +SDL_Rect getSourceRectByID( uint64_t id, LandType::Value type ) { if(block_mapping.find(id) == block_mapping.end()) return {}; SDL_Rect ret_src = *block_mapping.at(id); switch ( type ) { - case OVERWORLD: + case LandType::OVERWORLD: ret_src.x += OVERWORLD_SHIFT.getX(); ret_src.y += OVERWORLD_SHIFT.getY(); break; - case UNDERWORLD: + case LandType::UNDERWORLD: ret_src.x += UNDERWORLD_SHIFT.getX(); ret_src.y += UNDERWORLD_SHIFT.getY(); break; - case WATER: + case LandType::WATER: ret_src.x += WATER_SHIFT.getX(); ret_src.y += WATER_SHIFT.getY(); break; - case BOWSER: + case LandType::BOWSER: ret_src.x += BOWSER_SHIFT.getX(); ret_src.y += BOWSER_SHIFT.getY(); break; } return ret_src; } -std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, int x, int y, std::shared_ptr texture, bool collision ) { +std::shared_ptr createTerrainBlock( uint64_t block_id, LandType::Value type, std::shared_ptr &renderer, int x, int y, std::shared_ptr texture, bool collision ) { return createBlock( renderer, x, y, texture, getSourceRectByID( block_id, type ), block_id, collision ); } -std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, std::shared_ptr texture, bool collision ) { +std::shared_ptr createTerrainBlock( uint64_t block_id, LandType::Value type, std::shared_ptr &renderer, std::shared_ptr texture, bool collision ) { return createTerrainBlock( block_id, type, renderer, 0, 0, texture, collision ); } std::shared_ptr< SDLPP::RectangleRender > -createTerrainBlock( uint64_t block_id, BlockType type, +createTerrainBlock( uint64_t block_id, LandType::Value type, std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y, bool collision ) { return createTerrainBlock(block_id, type, renderer, x, y, g_terrain_texture, collision); } std::shared_ptr< SDLPP::RectangleRender > -createTerrainBlock( uint64_t block_id, BlockType type, +createTerrainBlock( uint64_t block_id, LandType::Value type, std::shared_ptr< SDLPP::Renderer > &renderer, bool collision ) { return createTerrainBlock(block_id, type, renderer, g_terrain_texture, collision); } -std::shared_ptr createMario( BlockType type, std::shared_ptr &renderer, int x, int y ) { +std::shared_ptr createMario( LandType::Value type, std::shared_ptr &renderer, int x, int y ) { //TODO add type additions auto mario = createBlock( renderer, x, y, g_mario_texture, MARIO_STANDING_SRC, MARIO_ID, true ); dynamic_cast(*mario).setTerrain(false); return mario; } + +enum BlockRole::Value getBlockRole(uint64_t id) { + if(id >= 0x7000) + return BlockRole::TERRAIN; + if(id == MARIO_ID) + return BlockRole::MARIO; + //TODO modifier/character + return BlockRole::MODIFIER; +} diff --git a/mario/blocks.hpp b/mario/blocks.hpp index 69b9eeb..cd5484b 100644 --- a/mario/blocks.hpp +++ b/mario/blocks.hpp @@ -17,19 +17,32 @@ private: extern const std::vector possibleBlocks; -enum BlockType { - OVERWORLD = 0, - UNDERWORLD = 1, - WATER = 2, - BOWSER = 4 +struct LandType { + enum Value { + OVERWORLD = 0, + UNDERWORLD = 1, + WATER = 2, + BOWSER = 4 + }; }; -std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, bool collision = false ); -std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, int x, int y, bool collision = false ); -std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, std::shared_ptr texture, bool collision = false ); -std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, int x, int y, std::shared_ptr texture, bool collision = false ); -std::shared_ptr createMario( BlockType type, std::shared_ptr &renderer, int x, int y ); +struct BlockRole { + enum Value { + TERRAIN, + MODIFIER, + CHARACTER, + MARIO, + }; +}; -SDL_Rect getSourceRectByID( uint64_t id, BlockType type ); +std::shared_ptr createTerrainBlock( uint64_t block_id, LandType::Value type, std::shared_ptr &renderer, bool collision = false ); +std::shared_ptr createTerrainBlock( uint64_t block_id, LandType::Value type, std::shared_ptr &renderer, int x, int y, bool collision = false ); +std::shared_ptr createTerrainBlock( uint64_t block_id, LandType::Value type, std::shared_ptr &renderer, std::shared_ptr texture, bool collision = false ); +std::shared_ptr createTerrainBlock( uint64_t block_id, LandType::Value type, std::shared_ptr &renderer, int x, int y, std::shared_ptr texture, bool collision = false ); +std::shared_ptr createMario( LandType::Value type, std::shared_ptr &renderer, int x, int y ); + +SDL_Rect getSourceRectByID( uint64_t id, LandType::Value type ); + +enum BlockRole::Value getBlockRole(uint64_t id); #endif diff --git a/mario/editor.cpp b/mario/editor.cpp index bb63c64..b8e115f 100644 --- a/mario/editor.cpp +++ b/mario/editor.cpp @@ -21,24 +21,32 @@ #include "editor_visitor.hpp" #include "tool_box.hpp" -std::shared_ptr< SDLPP::Renderer > renderer = nullptr; -bool quit = false; -bool update_size = false; -std::vector,16>> objects = {}; -uint64_t current_selected_flags = 0; -uint64_t previous_selected_flags = 0; -std::mutex destruction_mutex; +struct MouseInfo { + enum Index { + CUR_FLAGS = 0, + PREV_FLAGS = 1, + EDIT_BOX = 2, + TOOL_BOX = 3, + }; +}; -int current_start_index = 0; -int current_max_index = 0; -uint64_t current_block = 0; -SDLPP::Vec2D current_box = {0, 0}; -SDLPP::Vec2D current_tool_box = {0, 0}; +std::shared_ptr< SDLPP::Renderer > g_renderer = nullptr; +bool g_quit = false; +bool g_update_size = false; +std::vector g_objects = {}; +std::mutex g_destruction_mutex; -std::vector> tools{}; -std::shared_ptr current_tool = nullptr; -int current_tool_index = 0; -int max_tool_index = 0; +// current mouse flags, previous mouse flags, selected edit box, selected tool box +std::tuple, SDLPP::Vec2D> g_mouse_info; + +int g_current_start_index = 0; +int g_current_max_index = 0; +uint64_t g_current_block = 0; + +std::vector> g_tools{}; +std::shared_ptr g_current_tool = nullptr; +int g_current_tool_index = 0; +int g_max_tool_index = 0; std::shared_ptr g_placeholder_texture = nullptr; std::shared_ptr g_placeholder_mario = nullptr; @@ -46,19 +54,90 @@ std::shared_ptr g_placeholder_mario = nullptr; std::shared_ptr g_mario = nullptr; SDLPP::Vec2D g_mario_pos = {0,0}; -void handleKeyDown( SDL_Keycode key, SDLPP::Scene &scene ) { +enum LandType::Value g_current_world_type = LandType::OVERWORLD; + +void updateTool() { + auto tool_role = getBlockRole(possibleBlocks[g_current_block]); + std::shared_ptr target_texture = nullptr; + switch(tool_role) { + case BlockRole::TERRAIN: + target_texture = g_placeholder_texture; + break; + case BlockRole::MARIO: + target_texture = g_placeholder_mario; + break; + case BlockRole::MODIFIER: + break; + case BlockRole::CHARACTER: + break; + } + g_current_tool->setTexture(target_texture, getSourceRectByID(possibleBlocks[g_current_block], g_current_world_type)); + g_current_tool->setId(possibleBlocks[g_current_block]); + g_current_tool->getCollisions()[0]->setId(possibleBlocks[g_current_block]); +} + +void removeMario() { + if(!g_mario) + return; + auto prev = g_objects[g_mario_pos.getX()][g_mario_pos.getY()]; + // remove character/modifiers + g_objects[g_mario_pos.getX()][g_mario_pos.getY()] = {std::get<0>(prev), std::get<1>(prev), 0, 0, 0, 0}; + g_mario->destroy(); +} + +void updateToolSelection(int prev_index) { + size_t prev = prev_index * 8; + size_t cur = g_current_tool_index * 8; + for(size_t i = prev; i < (g_tools.size() < prev + 8 ? g_tools.size() : prev + 8); i++) { + g_tools[i]->setHidden(true); + } + for(size_t i = cur; i < (g_tools.size() < cur + 8 ? g_tools.size() : cur + 8); i++) { + g_tools[i]->setHidden(false); + } +} + +void moveToolsLeft() { + g_current_tool_index--; + updateToolSelection(g_current_tool_index + 1); +} + +void moveToolsRight() { + g_current_tool_index++; + updateToolSelection(g_current_tool_index - 1); +} + +// TODO add red outline to currently selected tool +// add WSAD navigation for the red highlight +void selectPrevTool() { + if(g_current_block == 0) + return; + if(g_current_block % 8 == 0) { + moveToolsLeft(); + } + g_current_block--; + updateTool(); +} + +void selectNextTool() { + if(g_current_block == g_tools.size() - 1) + return; + if(g_current_block % 8 == 7) { + moveToolsRight(); + } + g_current_block++; + updateTool(); +} + +void handleKeyUp( SDL_Keycode key, SDLPP::Scene &scene ) { switch ( key ) { case SDLK_ESCAPE: - quit = true; + g_quit = true; break; case SDLK_a: + selectPrevTool(); break; case SDLK_d: - break; - case SDLK_SPACE: - case SDLK_w: - break; - case SDLK_s: + selectNextTool(); break; case SDLK_r: scene.getRenderer().setRenderColiders( @@ -68,47 +147,120 @@ void handleKeyDown( SDL_Keycode key, SDLPP::Scene &scene ) { } } -void updateTool() { - if(possibleBlocks[current_block] == MARIO_ID) { - current_tool->setTexture(g_placeholder_mario, getSourceRectByID(possibleBlocks[current_block], OVERWORLD)); - } else { - current_tool->setTexture(g_placeholder_texture, getSourceRectByID(possibleBlocks[current_block], OVERWORLD)); - } - current_tool->setId(possibleBlocks[current_block]); - current_tool->getCollisions()[0]->setId(possibleBlocks[current_block]); -} +void getMousePositionFlags(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)); -void removeMario() { - auto prev = objects[g_mario_pos.getX()][g_mario_pos.getY()]; - objects[g_mario_pos.getX()][g_mario_pos.getY()] = {std::get<0>(prev), std::get<1>(prev), 0, 0, 0, 0}; - g_mario->destroy(); -} - -void updateToolSelection(int prev_index) { - auto prev = prev_index * 8; - auto cur = current_tool_index * 8; - for(int i = prev; i < (tools.size() < prev + 8 ? tools.size() : prev + 8); i++) { - tools[i]->setHidden(true); - } - for(int i = cur; i < (tools.size() < cur + 8 ? tools.size() : cur + 8); i++) { - tools[i]->setHidden(false); + MouseVisitor visitor; + scene.visitCollisions(*mouse, visitor); + std::get(g_mouse_info) = visitor.getFlags(); + std::get(g_mouse_info) = visitor.getEditBoxIndexes(); + std::get(g_mouse_info) = visitor.getToolBoxIndexes(); + // if we found an edit box, move tool icon to that box + if(visitor.foundEditBox()) { + const auto &box = std::get(g_mouse_info); + g_current_tool->setPos(BLOCK_SIZE + box.getX() * BLOCK_SIZE, 4*BLOCK_SIZE + box.getY() * BLOCK_SIZE); } } -void handleKeyUp( SDL_Keycode key ) { - switch ( key ) { - case SDLK_a: -// current_block = (current_block + possibleBlocks.size() - 1) % possibleBlocks.size(); -// updateTool(); - break; - case SDLK_d: -// current_block = (current_block + 1) % possibleBlocks.size(); -// updateTool(); - break; - case SDLK_w: - case SDLK_s: - default: - break; +void mouseUpAction(uint64_t flags, SDLPP::Scene &scene) { + if(MouseVisitor::moveMapLeft(flags) && g_current_start_index != 0) { + g_current_start_index -= 1; + scene.moveEverything(BLOCK_SIZE, 0); + } + if(MouseVisitor::moveMapRight(flags)) { + if(g_current_start_index == g_current_max_index) { + // add column + // TODO 18 as constant + g_objects.resize(g_current_max_index + 18 + 1); + g_current_max_index++; + } + g_current_start_index += 1; + scene.moveEverything(-BLOCK_SIZE,0); + } + if(MouseVisitor::moveToolsLeft(flags) && g_current_tool_index != 0) { + g_current_tool_index -= 1; + updateToolSelection(g_current_tool_index + 1); + } + if(MouseVisitor::moveToolsRight(flags) && g_current_tool_index != g_max_tool_index) { + g_current_tool_index += 1; + updateToolSelection(g_current_tool_index - 1); + } +} + +SDLPP::Vec2D getSelectedObjectPosition() { + return { g_current_start_index + std::get(g_mouse_info).getX(), std::get(g_mouse_info).getY() }; +} + +mapObjectType &getSelectedObject() { + auto pos = getSelectedObjectPosition(); + return g_objects[pos.getX()][pos.getY()]; +} + +void placeTool(SDLPP::Scene &scene) { + std::lock_guard lock(g_destruction_mutex); + + ToolVisitor visitor; + auto tool_type = getBlockRole(g_current_tool->getId()); + switch(tool_type) { + case BlockRole::TERRAIN: + visitor.setVisitorType(VisitorType::Terrain); + break; + default: + visitor.setVisitorType(VisitorType::Modifier); + break; + } + + scene.visitCollisions(*g_current_tool, visitor); + if(visitor.removeBlock() && !visitor.addBlock()) { + auto &obj = getSelectedObject(); + switch(visitor.getVisitorType()) { + case VisitorType::Terrain: + std::get(obj) = LandType::OVERWORLD; + std::get(obj) = 0; + break; + case VisitorType::Modifier: + std::get(obj) = 0; + std::get(obj) = 0; + std::get(obj) = 0; + std::get(obj) = 0; + break; + default: + break; + } + } else if(visitor.addBlock()) { + auto &obj = getSelectedObject(); + int z_index = 1; + std::shared_ptr new_obj = nullptr; + switch(visitor.getVisitorType()) { + case VisitorType::Terrain: + std::get(obj) = LandType::OVERWORLD; + std::get(obj) = g_current_tool->getId(); + // TODO why 1 +? + new_obj = createTerrainBlock(g_current_tool->getId(), LandType::OVERWORLD, g_renderer, 1 + std::get(g_mouse_info).getX(), std::get(g_mouse_info).getY(), true); + new_obj->getCollisions()[0]->setId(EDITOR_TERRAIN_ID); + break; + case VisitorType::Modifier: + // TODO check if modifier or character + std::get(obj) = LandType::OVERWORLD; + // TODO character ID + std::get(obj) = MARIO_ID; + std::get(obj) = 0; + std::get(obj) = 0; + new_obj = createMario(LandType::OVERWORLD, g_renderer, 1 + std::get(g_mouse_info).getX(), std::get(g_mouse_info).getY()); + // remove mario if exists + removeMario(); + g_mario = new_obj; + g_mario_pos = getSelectedObjectPosition(); + new_obj->getCollisions()[0]->setId(EDITOR_CHARACTER_ID); + z_index = scene.getObjects().size() - 1; + break; + default: + break; + } + scene.addObject(new_obj); + scene.setZIndex(new_obj, z_index); } } @@ -117,106 +269,38 @@ void pollEvents( SDLPP::Scene &scene ) { while ( SDLPP::getSDLEvent( event ) ) { switch ( event.type ) { case SDL_QUIT: - quit = true; - break; - case SDL_KEYDOWN: - if ( !event.key.repeat ) - handleKeyDown( event.key.keysym.sym, scene ); + g_quit = true; break; case SDL_KEYUP: - handleKeyUp( event.key.keysym.sym ); + handleKeyUp( event.key.keysym.sym, scene ); break; case SDL_WINDOWEVENT: if ( event.window.event == SDL_WINDOWEVENT_RESIZED ) { - update_size = true; + g_update_size = true; } break; - case SDL_MOUSEMOTION: { - auto mouse = scene.getObjects({EDITOR_MOUSE_ID})[0]; - mouse->setPos(SDLPP::Mouse::getMousePositionDouble(scene.getRenderer(), SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER)); - MouseVisitor visitor; - scene.visitCollisions(*mouse, visitor); - current_selected_flags = visitor.getFlags(); - current_box = visitor.getEditBoxIndexes(); - if(visitor.foundEditBox()) { - current_tool->setPos(BLOCK_SIZE + current_box.getX() * BLOCK_SIZE, 4*BLOCK_SIZE + current_box.getY() * BLOCK_SIZE); - } - current_tool_box = visitor.getToolBoxIndexes(); - } + case SDL_MOUSEMOTION: + getMousePositionFlags(scene); break; case SDL_MOUSEBUTTONUP: - if(previous_selected_flags == current_selected_flags && MouseVisitor::moveMapLeft(current_selected_flags) && current_start_index != 0) { - current_start_index -= 1; - scene.moveEverything(BLOCK_SIZE, 0); + if(std::get(g_mouse_info) == std::get(g_mouse_info)) { + mouseUpAction(std::get(g_mouse_info), scene); } - if(previous_selected_flags == current_selected_flags && MouseVisitor::moveMapRight(current_selected_flags)) { - if(current_start_index == current_max_index) { - objects.resize(current_max_index + 18 + 1); - current_max_index++; - } - current_start_index += 1; - scene.moveEverything(-BLOCK_SIZE,0); + if(std::get(g_mouse_info).getX() != -1) { + placeTool(scene); } - if(previous_selected_flags == current_selected_flags && MouseVisitor::moveToolsLeft(current_selected_flags) && current_tool_index != 0) { - current_tool_index -= 1; - updateToolSelection(current_tool_index + 1); - } - if(previous_selected_flags == current_selected_flags && MouseVisitor::moveToolsRight(current_selected_flags) && current_tool_index != max_tool_index) { - current_tool_index += 1; - updateToolSelection(current_tool_index - 1); - } - if(current_box.getX() != -1) { - std::lock_guard lock(destruction_mutex); - - ToolVisitor visitor; - if(current_tool->getId() < 0x7000) { - visitor.setVisitorType(MODIFIER_VISITOR_TYPE); - } else { - visitor.setVisitorType(TOOL_VISITOR_TYPE); - } - // TODO - scene.visitCollisions(*current_tool, visitor); - if(visitor.removeBlock() && !visitor.addBlock()) { - auto prev = objects[current_start_index + current_box.getX()][current_box.getY()]; - if(visitor.getVisitorType() == TOOL_VISITOR_TYPE) { - objects[current_start_index + current_box.getX()][current_box.getY()] = {OVERWORLD, 0, std::get<2>(prev), std::get<3>(prev), std::get<4>(prev), std::get<5>(prev)}; - } else { - objects[current_start_index + current_box.getX()][current_box.getY()] = {std::get<0>(prev), std::get<1>(prev), 0, 0, 0, 0}; - } - } else if(visitor.addBlock()) { - auto prev = objects[current_start_index + current_box.getX()][current_box.getY()]; - int z_index = 1; - std::shared_ptr obj = nullptr; - if(visitor.getVisitorType() == TOOL_VISITOR_TYPE) { - objects[current_start_index + current_box.getX()][current_box.getY()] = {OVERWORLD, current_tool->getId(), std::get<2>(prev), std::get<3>(prev), std::get<4>(prev), std::get<5>(prev)}; - obj = createTerrainBlock(current_tool->getId(), OVERWORLD, renderer, 1 + current_box.getX(), current_box.getY(), true); - obj->getCollisions()[0]->setId(EDITOR_TERRAIN_ID); - } else { - // TODO check if modifier or character - objects[current_start_index + current_box.getX()][current_box.getY()] = {std::get<0>(prev), std::get<1>(prev), OVERWORLD, MARIO_ID, 0, 0}; - obj = createMario(OVERWORLD, renderer, 1 + current_box.getX(), current_box.getY()); - if(g_mario) { - removeMario(); - } - g_mario = obj; - g_mario_pos = {current_start_index + current_box.getX(), current_box.getY()}; - obj->getCollisions()[0]->setId(EDITOR_CHARACTER_ID); - z_index = scene.getObjects().size() - 1; - } - scene.addObject(obj); - scene.setZIndex(obj, z_index); - } - } - if(current_tool_box.getX() != -1) { - auto index = current_tool_box.getY() * 4 + current_tool_box.getX(); - if(index < tools.size()) { - current_block = current_tool_index * 8 + index; + if(std::get(g_mouse_info).getX() != -1) { + auto &tool_box = std::get(g_mouse_info); + size_t index = tool_box.getY() * 4 + tool_box.getX(); + if(index < g_tools.size()) { + g_current_block = g_current_tool_index * 8 + index; updateTool(); } } break; case SDL_MOUSEBUTTONDOWN: - previous_selected_flags = current_selected_flags; + // store current mouse flags in previous mouse flags + std::get(g_mouse_info) = std::get(g_mouse_info); break; default: break; @@ -246,35 +330,35 @@ int main() { w.setResizable( true ); BLOCK_SIZE = 1.0 / 20; - renderer = std::make_shared< SDLPP::Renderer >( w ); - renderer->setBlendMode( SDL_BLENDMODE_BLEND ); + g_renderer = std::make_shared< SDLPP::Renderer >( w ); + g_renderer->setBlendMode( SDL_BLENDMODE_BLEND ); // prepare global vars g_terrain_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); + g_renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); g_mario_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); + g_renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); - auto scene = std::make_shared< SDLPP::Scene >( renderer ); + auto scene = std::make_shared< SDLPP::Scene >( g_renderer ); auto bg = std::make_shared< SDLPP::RectangleRender >( - 0, 0, 10, 10, renderer, MARIO_OVERWORLD_COLORKEY, true ); + 0, 0, 10, 10, g_renderer, MARIO_OVERWORLD_COLORKEY, true ); bg->setPermanent(); bg->setId( 1 ); scene->addObject( bg ); - loadMap( scene, "test_binary.bin", renderer, objects ); + loadMap( scene, "test_binary.bin", g_renderer, g_objects ); // grid for ( int i = 1; i < 20; i++ ) { auto line_vertical = std::make_shared< SDLPP::LineRenderer >( - i * BLOCK_SIZE, 1 - 16 * BLOCK_SIZE, i * BLOCK_SIZE, 1.0, renderer, "#282828" ); + i * BLOCK_SIZE, 1 - 16 * BLOCK_SIZE, i * BLOCK_SIZE, 1.0, g_renderer, "#282828" ); line_vertical->setPermanent(); line_vertical->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); scene->addObject(line_vertical); if(i > 2) { auto line_horizontal = std::make_shared< SDLPP::LineRenderer >( BLOCK_SIZE, ( i + 1 ) * BLOCK_SIZE, 19 * BLOCK_SIZE, - ( i + 1 ) * BLOCK_SIZE, renderer, "#282828" ); + ( i + 1 ) * BLOCK_SIZE, g_renderer, "#282828" ); line_horizontal->setPermanent(); line_horizontal->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); scene->addObject(line_horizontal); @@ -282,7 +366,7 @@ int main() { } // white rectangles auto rectangle1 = std::make_shared< SDLPP::RectangleRender >( - 0, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE, renderer, "#FFFFFF88", true); + 0, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE, g_renderer, "#FFFFFF88", true); rectangle1->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); rectangle1->setId(EDITOR_LEFT_MAP_ID); rectangle1->setPermanent(); @@ -290,7 +374,7 @@ int main() { scene->addObject(rectangle1); // white rectangles auto rectangle2 = std::make_shared< SDLPP::RectangleRender >( - 19*BLOCK_SIZE, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE, renderer, "#FFFFFF88", true); + 19*BLOCK_SIZE, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE, g_renderer, "#FFFFFF88", true); rectangle2->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); rectangle2->setId(EDITOR_RIGHT_MAP_ID); rectangle2->setPermanent(); @@ -301,13 +385,13 @@ int main() { auto font_config = std::make_shared< SDLPP::FontConfiguration >( font, "#000000", "#282828", 0.05 ); auto left = std::make_shared< SDLPP::TextRenderer >( - 0, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer, "<", font_config); + 0, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, "<", font_config); left->setId(0); left->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); left->setPermanent(); scene->addObject(left); auto right = std::make_shared< SDLPP::TextRenderer >( - 19*BLOCK_SIZE, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer, ">", font_config); + 19*BLOCK_SIZE, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, ">", font_config); right->setId(0); right->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); right->setPermanent(); @@ -315,12 +399,12 @@ int main() { for(int i = 0; i < 18; i++) { for(int j = 0; j < 16; j++) { - scene->addObject(std::make_shared(i, j, renderer)); + scene->addObject(std::make_shared(i, j, g_renderer)); } } 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, g_renderer ); mouse->setMinWidth(1); mouse->setMinHeight(1); mouse->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); @@ -329,13 +413,13 @@ int main() { mouse->addCollision( SDLPP::RectColider( { 0, 0 }, { 1, 1 } ) ); scene->addObject( mouse ); - current_max_index = objects.size() - 18; + g_current_max_index = g_objects.size() - 18; // tools - max_tool_index = (possibleBlocks.size() - 1) / 8; + g_max_tool_index = (possibleBlocks.size() - 1) / 8; for(int i = 0; i < 4; i++) { - auto tool_box1 = std::make_shared(i, 0, renderer); - auto tool_box2 = std::make_shared(i, 1, renderer); + auto tool_box1 = std::make_shared(i, 0, g_renderer); + auto tool_box2 = std::make_shared(i, 1, g_renderer); scene->addObject(tool_box1); scene->addObject(tool_box2); // std::cout << "TOOL BOX POS: " << tool_box1->getPos().getX() << ", " << tool_box1->getPos().getY() << std::endl; @@ -344,38 +428,38 @@ int main() { int tool_index = 0; for(auto &block : possibleBlocks) { if(block == MARIO_ID ) { - tools.push_back(createMario(OVERWORLD, renderer, 0, 0)); + g_tools.push_back(createMario(LandType::OVERWORLD, g_renderer, 0, 0)); } else { - tools.push_back(createTerrainBlock(block, OVERWORLD, renderer, false)); + g_tools.push_back(createTerrainBlock(block, LandType::OVERWORLD, g_renderer, false)); } - tools.back()->setHidden(true); - tools.back()->setPermanent(); + g_tools.back()->setHidden(true); + g_tools.back()->setPermanent(); auto x = tool_index % 4; auto y = tool_index / 4; // TODO add 14 and 1 as constants somewhere // TODO investigate when not permanent requires `-1` on x position - tools.back()->setPos(14*BLOCK_SIZE + x*BLOCK_SIZE, BLOCK_SIZE + y*BLOCK_SIZE); + g_tools.back()->setPos(14*BLOCK_SIZE + x*BLOCK_SIZE, BLOCK_SIZE + y*BLOCK_SIZE); // std::cout << "TOOL POS: " << tools.back()->getPos().getX() << ", " << tools.back()->getPos().getY() << std::endl; - scene->addObject(tools.back()); + scene->addObject(g_tools.back()); tool_index = (tool_index + 1) % 8; } for(int i = 0; i < 5; i++) { auto line = std::make_shared( - 14*BLOCK_SIZE + i*BLOCK_SIZE, BLOCK_SIZE, 14 * BLOCK_SIZE + i*BLOCK_SIZE, 3*BLOCK_SIZE, renderer, "#282828"); + 14*BLOCK_SIZE + i*BLOCK_SIZE, BLOCK_SIZE, 14 * BLOCK_SIZE + i*BLOCK_SIZE, 3*BLOCK_SIZE, g_renderer, "#282828"); line->setPermanent(); line->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); scene->addObject(line); } for(int i = 0; i < 3; i++) { auto line = std::make_shared( - 14*BLOCK_SIZE, BLOCK_SIZE + i*BLOCK_SIZE, 14 * BLOCK_SIZE + 4*BLOCK_SIZE, BLOCK_SIZE + i*BLOCK_SIZE, renderer, "#282828"); + 14*BLOCK_SIZE, BLOCK_SIZE + i*BLOCK_SIZE, 14 * BLOCK_SIZE + 4*BLOCK_SIZE, BLOCK_SIZE + i*BLOCK_SIZE, g_renderer, "#282828"); line->setPermanent(); line->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); scene->addObject(line); } auto tool_rect1 = std::make_shared< SDLPP::RectangleRender >( - 13*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, renderer, "#FFFFFF88", true); + 13*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, g_renderer, "#FFFFFF88", true); tool_rect1->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); tool_rect1->setId(EDITOR_LEFT_TOOL_ID); tool_rect1->setPermanent(); @@ -383,36 +467,36 @@ int main() { scene->addObject(tool_rect1); // white rectangles auto tool_rect2 = std::make_shared< SDLPP::RectangleRender >( - 18*BLOCK_SIZE, 1 * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, renderer, "#FFFFFF88", true); + 18*BLOCK_SIZE, 1 * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, g_renderer, "#FFFFFF88", true); tool_rect2->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); tool_rect2->setId(EDITOR_RIGHT_TOOL_ID); tool_rect2->setPermanent(); tool_rect2->addCollision(SDLPP::RectColider(0, 0, 1, 1)); scene->addObject(tool_rect2); auto left_tool = std::make_shared< SDLPP::TextRenderer >( - 13*BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer, "<", font_config); + 13*BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, "<", font_config); left_tool->setId(0); left_tool->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); left_tool->setPermanent(); scene->addObject(left_tool); auto right_tool = std::make_shared< SDLPP::TextRenderer >( - 18*BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer, ">", font_config); + 18*BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, ">", font_config); right_tool->setId(0); right_tool->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); right_tool->setPermanent(); scene->addObject(right_tool); g_placeholder_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); + g_renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); g_placeholder_texture->setAlpha(100); g_placeholder_mario = std::make_shared< SDLPP::Texture >( - renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); + g_renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); g_placeholder_mario->setAlpha(100); - current_tool = createTerrainBlock(possibleBlocks[current_block], OVERWORLD, renderer, g_placeholder_texture, false); - current_tool->addCollision(SDLPP::RectColider(0.1, 0.1, 0.8, 0.8)); - dynamic_cast(*current_tool).setTool(); - scene->addObject(current_tool); - scene->moveZTop(current_tool); + g_current_tool = createTerrainBlock(possibleBlocks[g_current_block], LandType::OVERWORLD, g_renderer, g_placeholder_texture, false); + g_current_tool->addCollision(SDLPP::RectColider(0.1, 0.1, 0.8, 0.8)); + dynamic_cast(*g_current_tool).setTool(); + scene->addObject(g_current_tool); + scene->moveZTop(g_current_tool); scene->moveEverything(BLOCK_SIZE, 0); FPSmanager gFPS; @@ -425,45 +509,45 @@ int main() { int frames = 0; std::thread inputThread( doInput, scene ); inputThread.detach(); - while ( !quit ) { + while ( !g_quit ) { SDL_PumpEvents(); SDL_framerateDelay( &gFPS ); - std::lock_guard lock(destruction_mutex); + std::lock_guard lock(g_destruction_mutex); scene->renderScene(); - renderer->presentRenderer(); + g_renderer->presentRenderer(); frames++; if ( SDL_GetTicks() - base >= 1000 ) { std::cout << "FPS: " << frames << std::endl; frames = 0; base = SDL_GetTicks(); } - if(current_start_index == 0) { + if(g_current_start_index == 0) { left->setTextColor(font, "#CCCCCC", "#CCCCCC", 0.05); } else { left->setTextColor(font, "#000000", "#282828", 0.05); } - if(current_start_index == current_max_index) { + if(g_current_start_index == g_current_max_index) { right->setTextColor(font, "#00FF00", "#000000", 0.1); right->changeText("+"); } else { right->setTextColor(font, "#000000", "#282828", 0.05); right->changeText(">"); } - if(current_tool_index == 0) { + if(g_current_tool_index == 0) { left_tool->setTextColor(font, "#CCCCCC", "#CCCCCC", 0.05); } else { left_tool->setTextColor(font, "#000000", "#282828", 0.05); } - if(current_tool_index == max_tool_index) { + if(g_current_tool_index == g_max_tool_index) { right_tool->setTextColor(font, "#CCCCCC", "#CCCCCC", 0.05); } else { right_tool->setTextColor(font, "#000000", "#282828", 0.05); } - if(update_size) { + if(g_update_size) { scene->updateSizeAndPosition(); } } - saveMap("test_binary2.bin", objects); + saveMap("test_binary2.bin", g_objects); return 0; } diff --git a/mario/editor_visitor.cpp b/mario/editor_visitor.cpp index db9326b..7d06a0f 100644 --- a/mario/editor_visitor.cpp +++ b/mario/editor_visitor.cpp @@ -62,12 +62,12 @@ void ToolVisitor::visit( const SDLPP::RenderObject &obj ) { switch ( id ) { case EDITOR_TERRAIN_ID: remove_block = true; - if(obj.getId() == source_id && getVisitorType() == TOOL_VISITOR_TYPE) { + if(obj.getId() == source_id && getVisitorType() == VisitorType::Terrain) { add_block = false; } case EDITOR_CHARACTER_ID: remove_block = true; - if(obj.getId() == source_id && getVisitorType() == MODIFIER_VISITOR_TYPE) { + if(obj.getId() == source_id && getVisitorType() == VisitorType::Modifier) { add_block = false; } default: diff --git a/mario/editor_visitor.hpp b/mario/editor_visitor.hpp index 379eb68..3d06849 100644 --- a/mario/editor_visitor.hpp +++ b/mario/editor_visitor.hpp @@ -5,6 +5,13 @@ #include "../sdlpp/sdlpp_geometry.hpp" #include +struct VisitorType { + enum Value { + Terrain = 0xE001, + Modifier = 0xE002, + }; +}; + class MouseVisitor : public SDLPP::Visitor { public: MouseVisitor() {} @@ -17,13 +24,13 @@ public: bool foundEditBox() { return edit_box; } - SDLPP::Vec2D getEditBoxIndexes() { + const SDLPP::Vec2D &getEditBoxIndexes() { return edit_box_location; } bool foundToolBox() { return tool_box; } - SDLPP::Vec2D getToolBoxIndexes() { + const SDLPP::Vec2D &getToolBoxIndexes() { return tool_box_location; } virtual void setVisitorType( uint64_t type ) override { diff --git a/mario/maploader.cpp b/mario/maploader.cpp index bf7be27..a3aed0f 100644 --- a/mario/maploader.cpp +++ b/mario/maploader.cpp @@ -39,7 +39,7 @@ void loadMap(std::shared_ptr &scene, std::shared_ptr(type), renderer, i, j, collision); + auto obj = createTerrainBlock(id, static_cast(type), renderer, i, j, collision); if(obj != nullptr) scene->addObject(obj); if(character) { @@ -53,7 +53,7 @@ void loadMap(std::shared_ptr &scene, std::shared_ptr &scene, const std::string &file, std::shared_ptr &renderer, std::vector,16>> &objects) { +void loadMap(std::shared_ptr &scene, const std::string &file, std::shared_ptr &renderer, std::vector &objects) { std::ifstream map_file; map_file.open(file, std::ios::in | std::ios::binary); uint16_t cols; @@ -84,12 +84,12 @@ void loadMap(std::shared_ptr &scene, const std::string &file, std: } col[j] = {type, id, character_type, character, modifier_type, modifier_data}; // TODO add modifiers to createTerrainBlock - auto obj = createTerrainBlock(id, static_cast(type), renderer, i, j, true); + auto obj = createTerrainBlock(id, static_cast(type), renderer, i, j, true); obj->getCollisions()[0]->setId(EDITOR_TERRAIN_ID); scene->addObject(obj); if(character) { if(character == MARIO_ID) { - scene->addObject(createMario(static_cast(character_type), renderer, i, j)); + scene->addObject(createMario(static_cast(character_type), renderer, i, j)); } } } @@ -100,7 +100,7 @@ void loadMap(std::shared_ptr &scene, const std::string &file, std: } // tuple - world object type, object, world character type, character, modifier type, modifier data -void saveMap(const std::string &file, std::vector,16>> &objects) { +void saveMap(const std::string &file, std::vector &objects) { std::ofstream output_file; output_file.open(file, std::ios::out | std::ios::binary); uint16_t cols = objects.size(); diff --git a/mario/maploader.hpp b/mario/maploader.hpp index a5b148d..0c9fbc4 100644 --- a/mario/maploader.hpp +++ b/mario/maploader.hpp @@ -4,8 +4,22 @@ #include "../sdlpp/sdlpp_scene.hpp" #include "../sdlpp/sdlpp_rectrenderer.hpp" +struct MapObject { + enum Index { + TERRAIN_TYPE = 0, + TERRAIN_ID = 1, + CHARACTER_TYPE = 2, + CHARACTER_ID = 3, + MODIFIER_TYPE = 4, + MODIFIER_DATA = 5, + }; +}; + +typedef std::tuple mapObjectType; +typedef std::array mapColumnType; + void loadMap(std::shared_ptr &scene, std::shared_ptr mario, const std::string &file, std::shared_ptr &renderer); -void loadMap(std::shared_ptr &scene, const std::string &file, std::shared_ptr &renderer, std::vector,16>> &objects); -void saveMap(const std::string &file, std::vector,16>> &objects); +void loadMap(std::shared_ptr &scene, const std::string &file, std::shared_ptr &renderer, std::vector &objects); +void saveMap(const std::string &file, std::vector &objects); #endif diff --git a/mario/objectids.hpp b/mario/objectids.hpp index e9e8b07..ccafbfa 100644 --- a/mario/objectids.hpp +++ b/mario/objectids.hpp @@ -85,8 +85,6 @@ #define EDITOR_RIGHT_TOOL_ID 0xF008 #define EDITOR_CHARACTER_ID 0xF009 -#define TOOL_VISITOR_TYPE 0xE001 -#define MODIFIER_VISITOR_TYPE 0xE002 #define MOUSE_VISITOR_TYPE 0xE003 #define MARIO_VISITOR_TYPE 0xE004