#include "../sdlpp/sdlpp.hpp" #include "sprites.hpp" #ifdef _WIN32 #include "../sdlpp/SDL2/SDL2_framerate.h" #include #include #include #else #include #endif // UNIX #include #include #include #include "global_vars.hpp" #include "objectids.hpp" #include "blocks.hpp" #include "maploader.hpp" #include "../sdlpp/sdlpp_mouse.hpp" #include "edit_box.hpp" #include "editor_visitor.hpp" #include "tool_box.hpp" #define MAP_WIDTH 18 #define MAP_HEIGHT 16 #define QUIT_FLAG 0x00000001 #define UPDATE_FLAG 0x00000002 #define MAP_LEFT_ENABLED_FLAG 0x00000004 #define MAP_RIGHT_ENABLED_FLAG 0x00000008 #define TOOL_LEFT_ENABLED_FLAG 0x00000010 #define TOOL_RIGHT_ENABLED_FLAG 0x00000020 #define MOD_LEFT_ENABLED_FLAG 0x00000040 #define MOD_RIGHT_ENABLED_FLAG 0x00000080 #define CHARACTER_LEFT_ENABLED_FLAG 0x00000100 #define CHARACTER_RIGHT_ENABLED_FLAG 0x00000200 #define TOOLS_WIDTH 4 #define CHARACTER_WIDTH 3 #define MOD_WIDTH 3 struct ToolType { enum Value { BLOCK, MOD, CHARACTER, }; }; struct MouseInfo { uint64_t cur_flags; uint64_t prev_flags; SDLPP::Vec2D< int > edit_box; SDLPP::Vec2D< int > tool_box; ToolType::Value tool_type; }; struct MapInfo { int cur_page; int max_page; }; struct ToolInfo { ToolType::Value type; uint64_t index; int cur_page_tools; int max_page_tools; int cur_page_mods; int max_page_mods; int cur_page_characters; int max_page_characters; }; struct GlobalVars { MouseInfo mouse; MapInfo map; ToolInfo tool; uint64_t flags; std::vector< mapColumnType > objects; std::vector< std::shared_ptr< SDLPP::RenderObject > > tools; std::vector< std::shared_ptr< SDLPP::RenderObject > > mods; std::vector< std::shared_ptr< SDLPP::RenderObject > > characters; std::shared_ptr< SDLPP::RenderObject > current_tool; std::shared_ptr< SDLPP::Texture > translucent_terrain_texture; std::shared_ptr< SDLPP::Texture > translucent_mario_texture; std::shared_ptr< SDLPP::RenderObject > mario; SDLPP::Vec2D< int > mario_pos; }; GlobalVars global_vars; std::mutex destruction_mutex; enum LandType::Value g_current_world_type = LandType::OVERWORLD; void updateTool() { auto tool_index = global_vars.tool.index; uint64_t tool_id = 0; switch(global_vars.tool.type) { case ToolType::BLOCK: tool_id = possibleBlocks[tool_index]; break; case ToolType::MOD: tool_id = possibleMods[tool_index]; break; case ToolType::CHARACTER: tool_id = possibleCharacters[tool_index]; default: break; } auto tool_role = getBlockRole( tool_id ); std::shared_ptr< SDLPP::Texture > target_texture = nullptr; switch ( tool_role ) { case BlockRole::TERRAIN: target_texture = global_vars.translucent_terrain_texture; break; case BlockRole::MARIO: target_texture = global_vars.translucent_mario_texture; break; case BlockRole::MODIFIER: target_texture = global_vars.translucent_terrain_texture; break; case BlockRole::CHARACTER: break; } global_vars.current_tool->setTexture( target_texture, getSourceRectByID( tool_id, g_current_world_type ) ); global_vars.current_tool->setId( tool_id ); global_vars.current_tool->getCollisions()[0]->setId( tool_id ); } void removeMario() { if ( !global_vars.mario ) return; auto prev = global_vars.objects[global_vars.mario_pos.getX()] [global_vars.mario_pos.getY()]; // remove character/modifiers global_vars .objects[global_vars.mario_pos.getX()][global_vars.mario_pos.getY()] = { std::get< 0 >( prev ), std::get< 1 >( prev ), 0, 0, 0, 0 }; global_vars.mario->destroy(); } void updateToolSelection( int prev_index, ToolType::Value type ) { size_t cur = 0; size_t multiplier = 0; std::vector< std::shared_ptr< SDLPP::RenderObject > > *tool_vec = nullptr; switch(type) { case ToolType::BLOCK: cur = global_vars.tool.cur_page_tools; multiplier = 2*TOOLS_WIDTH; tool_vec = &global_vars.tools; break; case ToolType::MOD: cur = global_vars.tool.cur_page_mods; multiplier = 2*MOD_WIDTH; tool_vec = &global_vars.mods; break; case ToolType::CHARACTER: cur = global_vars.tool.cur_page_characters; multiplier = 2*CHARACTER_WIDTH; tool_vec = &global_vars.characters; default: break; } cur *= multiplier; size_t prev = prev_index * multiplier; for ( size_t i = prev; i < ( tool_vec->size() < prev + multiplier ? tool_vec->size() : prev + multiplier ); i++ ) { tool_vec->at(i)->setHidden( true ); } for ( size_t i = cur; i < ( tool_vec->size() < cur + multiplier ? tool_vec->size() : cur + multiplier ); i++ ) { tool_vec->at(i)->setHidden( false ); } } void moveToolsLeft(ToolType::Value type) { switch(type) { case ToolType::BLOCK: global_vars.tool.cur_page_tools--; updateToolSelection( global_vars.tool.cur_page_tools + 1, type ); break; case ToolType::MOD: global_vars.tool.cur_page_mods--; updateToolSelection( global_vars.tool.cur_page_mods + 1, type ); break; case ToolType::CHARACTER: global_vars.tool.cur_page_characters--; updateToolSelection( global_vars.tool.cur_page_characters + 1, type ); default: break; } } void moveToolsRight(ToolType::Value type) { switch(type) { case ToolType::BLOCK: global_vars.tool.cur_page_tools++; updateToolSelection( global_vars.tool.cur_page_tools - 1, type ); break; case ToolType::MOD: global_vars.tool.cur_page_mods++; updateToolSelection( global_vars.tool.cur_page_mods - 1, type ); break; case ToolType::CHARACTER: global_vars.tool.cur_page_characters++; updateToolSelection( global_vars.tool.cur_page_characters - 1, type ); default: break; } } // TODO add red outline to currently selected tool // add WSAD navigation for the red highlight // add mouse wheel navigation void selectPrevTool() { int multiplier = 0; switch(global_vars.tool.type) { case ToolType::BLOCK: multiplier = 2*TOOLS_WIDTH; break; case ToolType::MOD: multiplier = 2*MOD_WIDTH; break; case ToolType::CHARACTER: multiplier = 2*CHARACTER_WIDTH; default: break; } if ( global_vars.tool.index == 0 ) return; if ( global_vars.tool.index % multiplier == 0 ) { moveToolsLeft(global_vars.tool.type); } global_vars.tool.index--; updateTool(); } void selectNextTool() { int multiplier = 0; size_t max_index = 0; switch(global_vars.tool.type) { case ToolType::BLOCK: multiplier = 2*TOOLS_WIDTH; max_index = global_vars.tools.size() - 1; break; case ToolType::MOD: multiplier = 2*MOD_WIDTH; max_index = global_vars.mods.size() - 1; break; case ToolType::CHARACTER: multiplier = 2*CHARACTER_WIDTH; max_index = global_vars.characters.size() - 1; default: break; } if ( global_vars.tool.index == max_index ) return; if ( global_vars.tool.index % multiplier == (multiplier-1) ) { moveToolsRight(global_vars.tool.type); } global_vars.tool.index++; updateTool(); } void setFlag( uint64_t flag ) { global_vars.flags |= flag; } void unsetFlag( uint64_t flag ) { global_vars.flags &= ~flag; } bool getFlag( uint64_t flag ) { return global_vars.flags & flag; } void handleKeyUp( SDL_Keycode key, SDLPP::Scene &scene ) { switch ( key ) { case SDLK_ESCAPE: setFlag( QUIT_FLAG ); break; case SDLK_a: selectPrevTool(); break; case SDLK_d: selectNextTool(); break; case SDLK_r: scene.getRenderer().setRenderColiders( !scene.getRenderer().getRenderColiders() ); default: break; } } 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 ) ); MouseVisitor visitor; scene.visitCollisions( *mouse, visitor ); global_vars.mouse.cur_flags = visitor.getFlags(); global_vars.mouse.edit_box = visitor.getEditBoxIndexes(); global_vars.mouse.tool_box = visitor.getToolBoxIndexes(); global_vars.mouse.tool_type = static_cast(visitor.getToolType()); // if we found an edit box, move tool icon to that box if ( visitor.foundEditBox() ) { const auto &box = global_vars.mouse.edit_box; global_vars.current_tool->setPos( BLOCK_SIZE + box.getX() * BLOCK_SIZE, ( MAP_WIDTH - MAP_HEIGHT + 2 ) * BLOCK_SIZE + box.getY() * BLOCK_SIZE ); } } void mouseUpAction( uint64_t flags, SDLPP::Scene &scene ) { if ( MouseVisitor::moveMapLeft( flags ) && global_vars.map.cur_page != 0 ) { global_vars.map.cur_page--; scene.moveEverything( BLOCK_SIZE, 0 ); } if ( MouseVisitor::moveMapRight( flags ) ) { if ( global_vars.map.cur_page == global_vars.map.max_page ) { // add column global_vars.objects.resize( global_vars.objects.size() + 1 ); global_vars.map.max_page++; } global_vars.map.cur_page += 1; scene.moveEverything( -BLOCK_SIZE, 0 ); } if ( MouseVisitor::moveToolsLeft( flags ) && global_vars.tool.cur_page_tools != 0 ) { global_vars.tool.cur_page_tools--; updateToolSelection( global_vars.tool.cur_page_tools + 1, ToolType::BLOCK ); } if ( MouseVisitor::moveToolsRight( flags ) && global_vars.tool.cur_page_tools != global_vars.tool.max_page_tools ) { global_vars.tool.cur_page_tools++; updateToolSelection( global_vars.tool.cur_page_tools - 1, ToolType::BLOCK ); } if ( MouseVisitor::moveModsLeft( flags ) && global_vars.tool.cur_page_mods != 0 ) { global_vars.tool.cur_page_mods--; updateToolSelection( global_vars.tool.cur_page_mods + 1, ToolType::MOD ); } if ( MouseVisitor::moveModsRight( flags ) && global_vars.tool.cur_page_mods != global_vars.tool.max_page_mods ) { global_vars.tool.cur_page_mods++; updateToolSelection( global_vars.tool.cur_page_mods - 1, ToolType::MOD ); } if ( MouseVisitor::moveCharactersLeft( flags ) && global_vars.tool.cur_page_characters != 0 ) { global_vars.tool.cur_page_characters--; updateToolSelection( global_vars.tool.cur_page_characters + 1, ToolType::CHARACTER ); } if ( MouseVisitor::moveCharactersRight( flags ) && global_vars.tool.cur_page_characters != global_vars.tool.max_page_characters ) { global_vars.tool.cur_page_characters++; updateToolSelection( global_vars.tool.cur_page_characters - 1, ToolType::CHARACTER ); } } SDLPP::Vec2D< int > getSelectedObjectPosition() { return global_vars.mouse.edit_box + SDLPP::Vec2D< int >( global_vars.map.cur_page, 0 ); } mapObjectType &getSelectedObject() { auto pos = getSelectedObjectPosition(); return global_vars.objects[pos.getX()][pos.getY()]; } void placeTool( SDLPP::Scene &scene ) { std::lock_guard< std::mutex > lock( destruction_mutex ); ToolVisitor visitor; auto tool_type = getBlockRole( global_vars.current_tool->getId() ); switch ( tool_type ) { case BlockRole::TERRAIN: visitor.setVisitorType( VisitorType::Terrain ); break; default: visitor.setVisitorType( VisitorType::Modifier ); break; } scene.visitCollisions( *global_vars.current_tool, visitor ); if ( visitor.removeBlock() && !visitor.addBlock() ) { auto &obj = getSelectedObject(); switch ( visitor.getVisitorType() ) { case VisitorType::Terrain: std::get< MapObject::TERRAIN_TYPE >( obj ) = LandType::OVERWORLD; std::get< MapObject::TERRAIN_ID >( obj ) = 0; break; case VisitorType::Modifier: std::get< MapObject::CHARACTER_TYPE >( obj ) = 0; std::get< MapObject::CHARACTER_ID >( obj ) = 0; std::get< MapObject::MODIFIER_TYPE >( obj ) = 0; std::get< MapObject::MODIFIER_DATA >( obj ) = 0; break; default: break; } } else if ( visitor.addBlock() ) { auto &obj = getSelectedObject(); auto renderer = scene.getRendererShared(); int z_index = 1; std::shared_ptr< SDLPP::RenderObject > new_obj = nullptr; switch ( visitor.getVisitorType() ) { case VisitorType::Terrain: std::get< MapObject::TERRAIN_TYPE >( obj ) = LandType::OVERWORLD; std::get< MapObject::TERRAIN_ID >( obj ) = global_vars.current_tool->getId(); // TODO why 1 +? new_obj = createTerrainBlock( global_vars.current_tool->getId(), LandType::OVERWORLD, renderer, 1 + global_vars.mouse.edit_box.getX(), global_vars.mouse.edit_box.getY(), true ); new_obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID ); break; case VisitorType::Modifier: if(tool_type == BlockRole::MARIO) { std::get< MapObject::CHARACTER_TYPE >( obj ) = LandType::OVERWORLD; std::get< MapObject::CHARACTER_ID >( obj ) = MARIO_ID; std::get< MapObject::MODIFIER_TYPE >( obj ) = 0; std::get< MapObject::MODIFIER_DATA >( obj ) = 0; new_obj = createMario( LandType::OVERWORLD, renderer, 1 + global_vars.mouse.edit_box.getX(), global_vars.mouse.edit_box.getY() ); // remove mario if exists removeMario(); global_vars.mario = new_obj; global_vars.mario_pos = getSelectedObjectPosition(); new_obj->getCollisions()[0]->setId( EDITOR_CHARACTER_ID ); z_index = scene.getObjects().size() - 1; // TODO BlockRole::Character } else { // TODO data std::get< MapObject::MODIFIER_TYPE >( obj ) = global_vars.current_tool->getId(); std::get< MapObject::MODIFIER_DATA >( obj ) = 0; new_obj = createTerrainBlock( global_vars.current_tool->getId(), LandType::OVERWORLD, renderer, 1 + global_vars.mouse.edit_box.getX(), global_vars.mouse.edit_box.getY(), global_vars.translucent_terrain_texture, true ); new_obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID ); // TODO createModifierBlock dynamic_cast(new_obj.get())->setTerrain(false); z_index = scene.getObjects().size() - 1; } break; default: break; } scene.addObject( new_obj ); scene.setZIndex( new_obj, z_index ); } } void pollEvents( SDLPP::Scene &scene ) { SDL_Event event; while ( SDLPP::getSDLEvent( event ) ) { switch ( event.type ) { case SDL_QUIT: setFlag( QUIT_FLAG ); break; case SDL_KEYUP: handleKeyUp( event.key.keysym.sym, scene ); break; case SDL_WINDOWEVENT: if ( event.window.event == SDL_WINDOWEVENT_RESIZED ) { setFlag( UPDATE_FLAG ); } break; case SDL_MOUSEMOTION: getMousePositionFlags( scene ); break; case SDL_MOUSEBUTTONUP: if ( global_vars.mouse.cur_flags == global_vars.mouse.prev_flags ) { mouseUpAction( global_vars.mouse.cur_flags, scene ); } if ( global_vars.mouse.edit_box.getX() != -1 ) { placeTool( scene ); } if ( global_vars.mouse.tool_box.getX() != -1 ) { auto &tool_box = global_vars.mouse.tool_box; int multiplier = 0; size_t max_index = 0; size_t cur_page = 0; switch(global_vars.mouse.tool_type) { case ToolType::BLOCK: multiplier = 2*TOOLS_WIDTH; max_index = global_vars.tools.size(); cur_page = global_vars.tool.cur_page_tools; break; case ToolType::MOD: multiplier = 2*MOD_WIDTH; max_index = global_vars.mods.size(); cur_page = global_vars.tool.cur_page_mods; break; case ToolType::CHARACTER: multiplier = 2*CHARACTER_WIDTH; max_index = global_vars.characters.size(); cur_page = global_vars.tool.cur_page_characters; default: break; } global_vars.tool.type = global_vars.mouse.tool_type; size_t index = tool_box.getY() * (multiplier/2) + tool_box.getX(); if ( index < max_index ) { global_vars.tool.index = cur_page * multiplier + index; updateTool(); } } break; case SDL_MOUSEBUTTONDOWN: // store current mouse flags in previous mouse flags global_vars.mouse.prev_flags = global_vars.mouse.cur_flags; break; default: break; } } } void doInput( std::shared_ptr< SDLPP::Scene > scene ) { FPSmanager gFPS; SDL_initFramerate( &gFPS ); SDL_setFramerate( &gFPS, 200 ); while ( true ) { SDL_framerateDelay( &gFPS ); pollEvents( *scene ); scene->updateScene(); } } void createGrid(double start_x, double start_y, int count_x, int count_y, std::shared_ptr &scene) { auto renderer = scene->getRendererShared(); auto width = count_x * BLOCK_SIZE; auto height = count_y * BLOCK_SIZE; for ( int i = 0; i < count_x + 1; i++ ) { auto line_vertical = std::make_shared< SDLPP::LineRenderer >( start_x + i * BLOCK_SIZE, start_y, start_x + i * BLOCK_SIZE, start_y + height, renderer, "#282828" ); line_vertical->setPermanent(); line_vertical->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); scene->addObject( line_vertical ); } for (int i = 0; i < count_y + 1; i++) { auto line_horizontal = std::make_shared< SDLPP::LineRenderer >( start_x, start_y + i * BLOCK_SIZE, start_x + width, start_y + i * BLOCK_SIZE, renderer, "#282828" ); line_horizontal->setPermanent(); line_horizontal->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); scene->addObject( line_horizontal ); } } std::pair, std::shared_ptr> createArrowControls(double left_x, double right_x, double start_y, double height, uint64_t left_id, uint64_t right_id, std::shared_ptr &scene) { auto renderer = scene->getRendererShared(); // white rectangles auto rectangle1 = std::make_shared< SDLPP::RectangleRender >( left_x, start_y, BLOCK_SIZE, height, renderer, "#FFFFFF88", true ); rectangle1->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); rectangle1->setId( left_id ); rectangle1->setPermanent(); rectangle1->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) ); scene->addObject( rectangle1 ); // white rectangles auto rectangle2 = std::make_shared< SDLPP::RectangleRender >( right_x, start_y, BLOCK_SIZE, height, renderer, "#FFFFFF88", true ); rectangle2->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); rectangle2->setId( right_id ); rectangle2->setPermanent(); rectangle2->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) ); scene->addObject( rectangle2 ); auto font = std::make_shared< SDLPP::Font >( "testfont.ttf", 36 ); auto font_config = std::make_shared< SDLPP::FontConfiguration >( font, "#000000", "#282828", 0.05 ); auto left = std::make_shared< SDLPP::TextRenderer >( left_x, start_y + height / 2.0 - 0.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, 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 >( right_x, start_y + height / 2.0 - 0.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer, ">", font_config ); right->setId( 0 ); right->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); right->setPermanent(); scene->addObject( right ); return {left, right}; } #ifdef _WIN32 int WINAPI wWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR szCmdLine, int nCmdShow ) { #else int main() { #endif //TODO the code setting up UI is terrible, terrible mess, make it cleaner SDLPP::init(); SDLPP::Window w( "Mario editor!" ); w.setResizable( true ); BLOCK_SIZE = 1.0 / ( MAP_WIDTH + 2 ); auto renderer = std::make_shared< SDLPP::Renderer >( w ); renderer->setBlendMode( SDL_BLENDMODE_BLEND ); // prepare global vars g_terrain_texture = std::make_shared< SDLPP::Texture >( renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); g_mario_texture = std::make_shared< SDLPP::Texture >( renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); g_translucent_terrain_texture = std::make_shared< SDLPP::Texture >( renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); g_translucent_terrain_texture->setAlpha( 100 ); auto scene = std::make_shared< SDLPP::Scene >( renderer ); auto bg = std::make_shared< SDLPP::RectangleRender >( 0, 0, 10, 10, renderer, MARIO_OVERWORLD_COLORKEY, true ); bg->setPermanent(); bg->setId( 1 ); scene->addObject( bg ); // TODO file name loadMap( scene, global_vars.mario, "test_binary.bin", renderer, global_vars.objects ); auto arrows = createArrowControls(0, (MAP_WIDTH + 1) * BLOCK_SIZE, (MAP_WIDTH + 2 - MAP_HEIGHT) * BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE, EDITOR_LEFT_MAP_ID, EDITOR_RIGHT_MAP_ID, scene); auto left = arrows.first; auto right = arrows.second; createGrid(BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, MAP_WIDTH, MAP_HEIGHT, scene); for ( int i = 0; i < MAP_WIDTH; i++ ) { for ( int j = 0; j < MAP_HEIGHT; j++ ) { scene->addObject( std::make_shared< EditBox >( i, j, MAP_WIDTH, MAP_HEIGHT, renderer ) ); } } auto mouse = std::make_shared< SDLPP::RectangleRender >( 0.01, 0.01, 0, 0, renderer ); mouse->setMinWidth( 1 ); mouse->setMinHeight( 1 ); mouse->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); mouse->setId( EDITOR_MOUSE_ID ); mouse->setColiderColor( "#00FF00" ); mouse->addCollision( SDLPP::RectColider( { 0, 0 }, { 1, 1 } ) ); scene->addObject( mouse ); global_vars.map.max_page = global_vars.objects.size() - MAP_WIDTH; global_vars.tool.max_page_tools = ( possibleBlocks.size() - 1 ) / (2*TOOLS_WIDTH); global_vars.tool.max_page_mods = ( possibleMods.size() - 1 ) / (2*MOD_WIDTH); global_vars.tool.max_page_characters = ( possibleCharacters.size() - 1 ) / (2*CHARACTER_WIDTH); // tools for ( int i = 0; i < TOOLS_WIDTH; i++ ) { auto tool_box1 = std::make_shared< ToolBox >( i, 0, (MAP_WIDTH - TOOLS_WIDTH) * BLOCK_SIZE, BLOCK_SIZE, renderer ); auto tool_box2 = std::make_shared< ToolBox >( i, 1, (MAP_WIDTH - TOOLS_WIDTH) * BLOCK_SIZE, BLOCK_SIZE, renderer ); tool_box1->setType(ToolType::BLOCK); tool_box2->setType(ToolType::BLOCK); scene->addObject( tool_box1 ); scene->addObject( tool_box2 ); } int tool_index = 0; for ( auto &block : possibleBlocks ) { global_vars.tools.push_back( createTerrainBlock( block, LandType::OVERWORLD, renderer, false ) ); global_vars.tools.back()->setHidden( true ); global_vars.tools.back()->setPermanent(); auto x = tool_index % TOOLS_WIDTH; auto y = tool_index / TOOLS_WIDTH; global_vars.tools.back()->setPos( ( MAP_WIDTH - TOOLS_WIDTH ) * BLOCK_SIZE + x * BLOCK_SIZE, BLOCK_SIZE + y * BLOCK_SIZE ); scene->addObject( global_vars.tools.back() ); tool_index = ( tool_index + 1 ) % (2*TOOLS_WIDTH); } arrows = createArrowControls((MAP_WIDTH - TOOLS_WIDTH - 1) * BLOCK_SIZE, MAP_WIDTH * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, EDITOR_LEFT_TOOL_ID, EDITOR_RIGHT_TOOL_ID, scene); auto left_tool = arrows.first; auto right_tool = arrows.second; createGrid(( MAP_WIDTH - TOOLS_WIDTH ) * BLOCK_SIZE, BLOCK_SIZE, TOOLS_WIDTH, 2, scene); //mods for ( int i = 0; i < MOD_WIDTH; i++ ) { auto mod_box1 = std::make_shared< ToolBox >( i, 0, 2*BLOCK_SIZE, BLOCK_SIZE, renderer ); auto mod_box2 = std::make_shared< ToolBox >( i, 1, 2*BLOCK_SIZE, BLOCK_SIZE, renderer ); mod_box1->setType(ToolType::MOD); mod_box2->setType(ToolType::MOD); scene->addObject( mod_box1 ); scene->addObject( mod_box2 ); } tool_index = 0; for ( auto &block : possibleMods ) { //TODO createModBlock global_vars.mods.push_back( createTerrainBlock( block, LandType::OVERWORLD, renderer, false ) ); global_vars.mods.back()->setHidden( true ); global_vars.mods.back()->setPermanent(); auto x = tool_index % MOD_WIDTH; auto y = tool_index / MOD_WIDTH; global_vars.mods.back()->setPos( 2*BLOCK_SIZE + x * BLOCK_SIZE, BLOCK_SIZE + y * BLOCK_SIZE ); scene->addObject( global_vars.mods.back() ); tool_index = ( tool_index + 1 ) % (2*MOD_WIDTH); } arrows = createArrowControls(BLOCK_SIZE, (MOD_WIDTH + 2) * BLOCK_SIZE, BLOCK_SIZE, 2*BLOCK_SIZE, EDITOR_LEFT_MOD_ID, EDITOR_RIGHT_MOD_ID, scene); auto left_mod = arrows.first; auto right_mod = arrows.second; createGrid(2*BLOCK_SIZE, BLOCK_SIZE, MOD_WIDTH, 2, scene); //characters for ( int i = 0; i < CHARACTER_WIDTH; i++ ) { auto char_box1 = std::make_shared< ToolBox >( i, 0, (MOD_WIDTH+5)*BLOCK_SIZE, BLOCK_SIZE, renderer ); auto char_box2 = std::make_shared< ToolBox >( i, 1, (MOD_WIDTH+5)*BLOCK_SIZE, BLOCK_SIZE, renderer ); char_box1->setType(ToolType::CHARACTER); char_box2->setType(ToolType::CHARACTER); scene->addObject( char_box1 ); scene->addObject( char_box2 ); } tool_index = 0; for ( auto &block : possibleCharacters ) { //TODO createCharacterBlock if ( block == MARIO_ID ) { global_vars.characters.push_back( createMario( LandType::OVERWORLD, renderer, 0, 0 ) ); } else { global_vars.characters.push_back( createTerrainBlock( block, LandType::OVERWORLD, renderer, false ) ); } global_vars.characters.back()->setHidden( true ); global_vars.characters.back()->setPermanent(); auto x = tool_index % CHARACTER_WIDTH; auto y = tool_index / CHARACTER_WIDTH; global_vars.characters.back()->setPos( (MOD_WIDTH + 5) * BLOCK_SIZE + x * BLOCK_SIZE, BLOCK_SIZE + y * BLOCK_SIZE ); scene->addObject( global_vars.characters.back() ); tool_index = ( tool_index + 1 ) % (2*CHARACTER_WIDTH); } arrows = createArrowControls((MOD_WIDTH + 4) * BLOCK_SIZE, (MOD_WIDTH + 5 + CHARACTER_WIDTH) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, EDITOR_LEFT_CHARACTER_ID, EDITOR_RIGHT_CHARACTER_ID, scene); auto left_char = arrows.first; auto right_char = arrows.second; createGrid((MOD_WIDTH + 5) * BLOCK_SIZE, BLOCK_SIZE, CHARACTER_WIDTH, 2, scene); auto font = std::make_shared< SDLPP::Font >( "testfont.ttf", 36 ); auto font_config = std::make_shared< SDLPP::FontConfiguration >( font, "#000000", "#282828", 0.05 ); global_vars.translucent_terrain_texture = std::make_shared< SDLPP::Texture >( renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); global_vars.translucent_terrain_texture->setAlpha( 100 ); global_vars.translucent_mario_texture = std::make_shared< SDLPP::Texture >( renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); global_vars.translucent_mario_texture->setAlpha( 100 ); global_vars.current_tool = createTerrainBlock( possibleBlocks[global_vars.tool.index], LandType::OVERWORLD, renderer, global_vars.translucent_terrain_texture, false ); global_vars.current_tool->addCollision( SDLPP::RectColider( 0.1, 0.1, 0.8, 0.8 ) ); dynamic_cast< MarioBlock & >( *global_vars.current_tool ).setTool(); scene->addObject( global_vars.current_tool ); scene->moveZTop( global_vars.current_tool ); scene->moveEverything( BLOCK_SIZE, 0 ); FPSmanager gFPS; SDL_initFramerate( &gFPS ); SDL_setFramerate( &gFPS, 60 ); updateToolSelection( 0, ToolType::BLOCK ); updateToolSelection( 0, ToolType::MOD ); updateToolSelection( 0, ToolType::CHARACTER ); auto base = SDL_GetTicks(); int frames = 0; std::thread inputThread( doInput, scene ); inputThread.detach(); setFlag( UPDATE_FLAG ); global_vars.tool.cur_page_tools = 0; global_vars.tool.cur_page_mods = 0; global_vars.tool.cur_page_characters = 0; // required for initial correct rendering setFlag( MAP_LEFT_ENABLED_FLAG ); setFlag( MAP_RIGHT_ENABLED_FLAG ); setFlag( TOOL_LEFT_ENABLED_FLAG ); setFlag( TOOL_RIGHT_ENABLED_FLAG ); setFlag( MOD_LEFT_ENABLED_FLAG ); setFlag( MOD_RIGHT_ENABLED_FLAG ); setFlag( CHARACTER_LEFT_ENABLED_FLAG ); setFlag( CHARACTER_RIGHT_ENABLED_FLAG ); while ( !getFlag( QUIT_FLAG ) ) { SDL_PumpEvents(); SDL_framerateDelay( &gFPS ); std::lock_guard< std::mutex > lock( destruction_mutex ); scene->renderScene(); renderer->presentRenderer(); frames++; if ( SDL_GetTicks() - base >= 1000 ) { std::cout << "FPS: " << frames << std::endl; frames = 0; base = SDL_GetTicks(); } if ( global_vars.map.cur_page == 0 && getFlag( MAP_LEFT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); unsetFlag( MAP_LEFT_ENABLED_FLAG ); left->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 ); } else if ( global_vars.map.cur_page != 0 && !getFlag( MAP_LEFT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); setFlag( MAP_LEFT_ENABLED_FLAG ); left->setTextColor( font, "#000000", "#282828", 0.05 ); } if ( global_vars.map.cur_page == global_vars.map.max_page && getFlag( MAP_RIGHT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); unsetFlag( MAP_RIGHT_ENABLED_FLAG ); right->setTextColor( font, "#00FF00", "#000000", 0.1 ); right->changeText( "+" ); } else if ( global_vars.map.cur_page != global_vars.map.max_page && !getFlag( MAP_RIGHT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); setFlag( MAP_RIGHT_ENABLED_FLAG ); right->setTextColor( font, "#000000", "#282828", 0.05 ); right->changeText( ">" ); } //TODO if ( global_vars.tool.cur_page_tools == 0 && getFlag( TOOL_LEFT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); unsetFlag( TOOL_LEFT_ENABLED_FLAG ); left_tool->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 ); } else if ( global_vars.tool.cur_page_tools != 0 && !getFlag( TOOL_LEFT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); setFlag( TOOL_LEFT_ENABLED_FLAG ); left_tool->setTextColor( font, "#000000", "#282828", 0.05 ); } if ( global_vars.tool.cur_page_tools == global_vars.tool.max_page_tools && getFlag( TOOL_RIGHT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); unsetFlag( TOOL_RIGHT_ENABLED_FLAG ); right_tool->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 ); } else if ( global_vars.tool.cur_page_tools != global_vars.tool.max_page_tools && !getFlag( TOOL_RIGHT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); setFlag( TOOL_RIGHT_ENABLED_FLAG ); right_tool->setTextColor( font, "#000000", "#282828", 0.05 ); } if ( global_vars.tool.cur_page_mods == 0 && getFlag( MOD_LEFT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); unsetFlag( MOD_LEFT_ENABLED_FLAG ); left_mod->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 ); } else if ( global_vars.tool.cur_page_mods != 0 && !getFlag( MOD_LEFT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); setFlag( MOD_LEFT_ENABLED_FLAG ); left_mod->setTextColor( font, "#000000", "#282828", 0.05 ); } if ( global_vars.tool.cur_page_mods == global_vars.tool.max_page_mods && getFlag( MOD_RIGHT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); unsetFlag( MOD_RIGHT_ENABLED_FLAG ); right_mod->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 ); } else if ( global_vars.tool.cur_page_mods != global_vars.tool.max_page_mods && !getFlag( MOD_RIGHT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); setFlag( MOD_RIGHT_ENABLED_FLAG ); right_mod->setTextColor( font, "#000000", "#282828", 0.05 ); } if ( global_vars.tool.cur_page_characters == 0 && getFlag( CHARACTER_LEFT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); unsetFlag( CHARACTER_LEFT_ENABLED_FLAG ); left_char->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 ); } else if ( global_vars.tool.cur_page_characters != 0 && !getFlag( CHARACTER_LEFT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); setFlag( CHARACTER_LEFT_ENABLED_FLAG ); left_char->setTextColor( font, "#000000", "#282828", 0.05 ); } if ( global_vars.tool.cur_page_characters == global_vars.tool.max_page_characters && getFlag( CHARACTER_RIGHT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); unsetFlag( CHARACTER_RIGHT_ENABLED_FLAG ); right_char->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 ); } else if ( global_vars.tool.cur_page_characters != global_vars.tool.max_page_characters && !getFlag( CHARACTER_RIGHT_ENABLED_FLAG ) ) { setFlag( UPDATE_FLAG ); setFlag( CHARACTER_RIGHT_ENABLED_FLAG ); right_char->setTextColor( font, "#000000", "#282828", 0.05 ); } if ( getFlag( UPDATE_FLAG ) ) { scene->updateSizeAndPosition(); unsetFlag( UPDATE_FLAG ); } } saveMap( "test_binary2.bin", global_vars.objects ); return 0; }