From 83cda5f860327a89f2d97a129eb41ef57d259934 Mon Sep 17 00:00:00 2001 From: zv0n Date: Sun, 9 May 2021 00:46:10 +0200 Subject: [PATCH] Mario editor: formatting --- mario/blocks.cpp | 287 ++++++++++++---------- mario/blocks.hpp | 45 ++-- mario/editor.cpp | 505 +++++++++++++++++++++------------------ mario/editor_visitor.cpp | 18 +- mario/editor_visitor.hpp | 22 +- mario/maploader.cpp | 159 ++++++------ mario/maploader.hpp | 16 +- mario/objectids.hpp | 1 - 8 files changed, 595 insertions(+), 458 deletions(-) diff --git a/mario/blocks.cpp b/mario/blocks.cpp index 93340c4..2d97c7f 100644 --- a/mario/blocks.cpp +++ b/mario/blocks.cpp @@ -5,131 +5,160 @@ #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 ) {} +MarioBlock::MarioBlock( int x, int y, + std::shared_ptr< SDLPP::Renderer > renderer, + std::shared_ptr< SDLPP::Texture > 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() == VisitorType::Terrain) { + if ( !_tool && _terrain && + visitor.getVisitorType() == VisitorType::Terrain ) { destroy(); } - if(!_tool && !_terrain && visitor.getVisitorType() == VisitorType::Modifier) { + if ( !_tool && !_terrain && + visitor.getVisitorType() == VisitorType::Modifier ) { destroy(); } - visitor.visit(*this); + visitor.visit( *this ); } -void MarioBlock::setTool(bool tool) { +void MarioBlock::setTool( bool tool ) { _tool = tool; } -void MarioBlock::setTerrain(bool terrain) { +void MarioBlock::setTerrain( bool terrain ) { _terrain = terrain; } -const std::vector< uint64_t > possibleBlocks = { FLOOR_ID, - STEP_ID, - HILL_TOP_ID, - HILL_DOTS_LEFT_ID, - HILL_FILL_ID, - HILL_INCLINE_ID, - HILL_DOTS_RIGHT_ID, - HILL_DECLINE_ID, - CLOUD_LEFT_TOP_ID, - CLOUD_MIDDLE_TOP_ID, - CLOUD_RIGHT_TOP_ID, - VINE_TOP_ID, - CLOUD_LEFT_BOTTOM_ID, - CLOUD_MIDDLE_BOTTOM_ID, - CLOUD_RIGHT_BOTTOM_ID, - VINE_BOTTOM_ID, - BRICK_TOP_ID, - BRICK_ID, - FLAG_ID, - WATER_TOP_ID, - BUSH_LEFT_ID, - BUSH_MIDDLE_ID, - BUSH_RIGHT_ID, - WATER_FILL_ID, - PIPE_LEFT_TOP_ID, - PIPE_RIGHT_TOP_ID, - CASTLE_TOWER_ID, - CASTLE_TOWER_FILLED_ID, - PIPE_LEFT_BOTTOM_ID, - PIPE_RIGHT_BOTTOM_ID, - CASTLE_LEFT_ID, - CASTLE_RIGHT_ID, - POLE_TOP_ID, - CASTLE_ENTRY_ID, - SIDEWAY_PIPE_END_TOP_ID, - SIDEWAY_PIPE_MIDDLE_TOP_ID, - POLE_BOTTOM_ID, - CASTLE_BLACK_ID, - SIDEWAY_PIPE_END_BOTTOM_ID, - SIDEWAY_PIPE_MIDDLE_BOTTOM_ID, - SIDEWAY_PIPE_CONNECTOR_TOP_ID, - TREE_PLATFORM_TOP_LEFT_ID, - TREE_PLATFORM_TOP_MIDDLE_ID, - TREE_PLATFORM_TOP_RIGHT_ID, - SIDEWAY_PIPE_CONNECTOR_BOTTOM_ID, - MUSHROOM_PLATFORM_TOP_LEFT_ID, - MUSHROOM_PLATFORM_TOP_MIDDLE_ID, - MUSHROOM_PLATFORM_TOP_RIGHT_ID, +const std::vector< uint64_t > possibleBlocks = { + FLOOR_ID, + STEP_ID, + HILL_TOP_ID, + HILL_DOTS_LEFT_ID, + HILL_FILL_ID, + HILL_INCLINE_ID, + HILL_DOTS_RIGHT_ID, + HILL_DECLINE_ID, + CLOUD_LEFT_TOP_ID, + CLOUD_MIDDLE_TOP_ID, + CLOUD_RIGHT_TOP_ID, + VINE_TOP_ID, + CLOUD_LEFT_BOTTOM_ID, + CLOUD_MIDDLE_BOTTOM_ID, + CLOUD_RIGHT_BOTTOM_ID, + VINE_BOTTOM_ID, + BRICK_TOP_ID, + BRICK_ID, + FLAG_ID, + WATER_TOP_ID, + BUSH_LEFT_ID, + BUSH_MIDDLE_ID, + BUSH_RIGHT_ID, + WATER_FILL_ID, + PIPE_LEFT_TOP_ID, + PIPE_RIGHT_TOP_ID, + CASTLE_TOWER_ID, + CASTLE_TOWER_FILLED_ID, + PIPE_LEFT_BOTTOM_ID, + PIPE_RIGHT_BOTTOM_ID, + CASTLE_LEFT_ID, + CASTLE_RIGHT_ID, + POLE_TOP_ID, + CASTLE_ENTRY_ID, + SIDEWAY_PIPE_END_TOP_ID, + SIDEWAY_PIPE_MIDDLE_TOP_ID, + POLE_BOTTOM_ID, + CASTLE_BLACK_ID, + SIDEWAY_PIPE_END_BOTTOM_ID, + SIDEWAY_PIPE_MIDDLE_BOTTOM_ID, + SIDEWAY_PIPE_CONNECTOR_TOP_ID, + TREE_PLATFORM_TOP_LEFT_ID, + TREE_PLATFORM_TOP_MIDDLE_ID, + TREE_PLATFORM_TOP_RIGHT_ID, + SIDEWAY_PIPE_CONNECTOR_BOTTOM_ID, + MUSHROOM_PLATFORM_TOP_LEFT_ID, + MUSHROOM_PLATFORM_TOP_MIDDLE_ID, + MUSHROOM_PLATFORM_TOP_RIGHT_ID, - TREE_PLATFORM_BARK_ID, - MUSHROOM_PLATFORM_BARK_TOP_ID, - TREE_LEAVES_TOP_ID, - TREE_LEAVES_SMALL_ID, - CANNON_TOWER_ID, - MUSHROOM_PLATFORM_BARK_BOTTOM_ID, - TREE_LEAVES_BOTTOM_ID, - TREE_BARK_ID, - CANNON_PEDESTAL_ID, - CANNON_ID, - MARIO_ID, + TREE_PLATFORM_BARK_ID, + MUSHROOM_PLATFORM_BARK_TOP_ID, + TREE_LEAVES_TOP_ID, + TREE_LEAVES_SMALL_ID, + CANNON_TOWER_ID, + MUSHROOM_PLATFORM_BARK_BOTTOM_ID, + TREE_LEAVES_BOTTOM_ID, + TREE_BARK_ID, + CANNON_PEDESTAL_ID, + CANNON_ID, + MARIO_ID, }; -const std::unordered_map block_mapping = { - {FLOOR_ID, &FLOOR_SRC}, {HILL_INCLINE_ID, &HILL_INCLINE_SRC}, - {HILL_DECLINE_ID, &HILL_DECLINE_SRC}, {HILL_DOTS_RIGHT_ID, &HILL_DOTS_RIGHT_SRC}, - {HILL_DOTS_LEFT_ID, &HILL_DOTS_LEFT_SRC}, {HILL_FILL_ID, &HILL_FILL_SRC}, - {HILL_TOP_ID, &HILL_TOP_SRC}, {BUSH_LEFT_ID, &BUSH_LEFT_SRC}, {BUSH_MIDDLE_ID, &BUSH_MIDDLE_SRC}, - {BUSH_RIGHT_ID, &BUSH_RIGHT_SRC}, {CLOUD_LEFT_BOTTOM_ID, &CLOUD_LEFT_BOTTOM_SRC}, - {CLOUD_MIDDLE_BOTTOM_ID, &CLOUD_MIDDLE_BOTTOM_SRC}, {CLOUD_RIGHT_BOTTOM_ID, &CLOUD_RIGHT_BOTTOM_SRC}, - {CLOUD_LEFT_TOP_ID, &CLOUD_LEFT_TOP_SRC}, {CLOUD_MIDDLE_TOP_ID, &CLOUD_MIDDLE_TOP_SRC}, - {CLOUD_RIGHT_TOP_ID, &CLOUD_RIGHT_TOP_SRC}, {PIPE_LEFT_BOTTOM_ID, &PIPE_LEFT_BOTTOM_SRC}, - {PIPE_LEFT_TOP_ID, &PIPE_LEFT_TOP_SRC}, {PIPE_RIGHT_BOTTOM_ID, &PIPE_RIGHT_BOTTOM_SRC}, - {PIPE_RIGHT_TOP_ID, &PIPE_RIGHT_TOP_SRC}, {CASTLE_LEFT_ID, &CASTLE_LEFT_SRC}, - {CASTLE_RIGHT_ID, &CASTLE_RIGHT_SRC}, {CASTLE_BLACK_ID, &CASTLE_BLACK_SRC}, - {CASTLE_ENTRY_ID, &CASTLE_ENTRY_SRC}, {CASTLE_TOWER_ID, &CASTLE_TOWER_SRC}, - {CASTLE_TOWER_FILLED_ID, &CASTLE_TOWER_FILLED_SRC}, {VINE_TOP_ID, &VINE_TOP_SRC}, - {VINE_BOTTOM_ID, &VINE_BOTTOM_SRC}, {POLE_TOP_ID, &POLE_TOP_SRC}, - {POLE_BOTTOM_ID, &POLE_BOTTOM_SRC}, {FLAG_ID, &FLAG_SRC}, - {STEP_ID, &STEP_SRC}, {BRICK_ID, &BRICK_SRC}, {BRICK_TOP_ID, &BRICK_TOP_SRC}, - {SIDEWAY_PIPE_END_TOP_ID, &SIDEWAY_PIPE_END_TOP_SRC}, - {SIDEWAY_PIPE_END_BOTTOM_ID, &SIDEWAY_PIPE_END_BOTTOM_SRC}, - {SIDEWAY_PIPE_MIDDLE_TOP_ID, &SIDEWAY_PIPE_MIDDLE_TOP_SRC}, - {SIDEWAY_PIPE_MIDDLE_BOTTOM_ID, &SIDEWAY_PIPE_MIDDLE_BOTTOM_SRC}, - {SIDEWAY_PIPE_CONNECTOR_TOP_ID, &SIDEWAY_PIPE_CONNECTOR_TOP_SRC}, - {SIDEWAY_PIPE_CONNECTOR_BOTTOM_ID, &SIDEWAY_PIPE_CONNECTOR_BOTTOM_SRC}, - {TREE_PLATFORM_TOP_LEFT_ID, &TREE_PLATFORM_TOP_LEFT_SRC}, - {TREE_PLATFORM_TOP_MIDDLE_ID, &TREE_PLATFORM_TOP_MIDDLE_SRC}, - {TREE_PLATFORM_TOP_RIGHT_ID, &TREE_PLATFORM_TOP_RIGHT_SRC}, - {TREE_PLATFORM_BARK_ID, &TREE_PLATFORM_BARK_SRC}, - {WATER_TOP_ID, &WATER_TOP_SRC}, {WATER_FILL_ID, &WATER_FILL_SRC}, - {MUSHROOM_PLATFORM_TOP_LEFT_ID, &MUSHROOM_PLATFORM_TOP_LEFT_SRC}, - {MUSHROOM_PLATFORM_TOP_MIDDLE_ID, &MUSHROOM_PLATFORM_TOP_MIDDLE_SRC}, - {MUSHROOM_PLATFORM_TOP_RIGHT_ID, &MUSHROOM_PLATFORM_TOP_RIGHT_SRC}, - {MUSHROOM_PLATFORM_BARK_TOP_ID, &MUSHROOM_PLATFORM_BARK_TOP_SRC}, - {MUSHROOM_PLATFORM_BARK_BOTTOM_ID, &MUSHROOM_PLATFORM_BARK_BOTTOM_SRC}, - {TREE_BARK_ID, &TREE_BARK_SRC}, {TREE_LEAVES_SMALL_ID, &TREE_LEAVES_SMALL_SRC}, - {TREE_LEAVES_TOP_ID, &TREE_LEAVES_TOP_SRC}, - {TREE_LEAVES_BOTTOM_ID, &TREE_LEAVES_BOTTOM_SRC}, - {CANNON_TOWER_ID, &CANNON_TOWER_SRC}, - {CANNON_PEDESTAL_ID, &CANNON_PEDESTAL_SRC}, - {CANNON_ID, &CANNON_SRC}, {MARIO_ID, &MARIO_STANDING_SRC} +const std::unordered_map< uint64_t, const SDL_Rect * > block_mapping = { + { FLOOR_ID, &FLOOR_SRC }, + { HILL_INCLINE_ID, &HILL_INCLINE_SRC }, + { HILL_DECLINE_ID, &HILL_DECLINE_SRC }, + { HILL_DOTS_RIGHT_ID, &HILL_DOTS_RIGHT_SRC }, + { HILL_DOTS_LEFT_ID, &HILL_DOTS_LEFT_SRC }, + { HILL_FILL_ID, &HILL_FILL_SRC }, + { HILL_TOP_ID, &HILL_TOP_SRC }, + { BUSH_LEFT_ID, &BUSH_LEFT_SRC }, + { BUSH_MIDDLE_ID, &BUSH_MIDDLE_SRC }, + { BUSH_RIGHT_ID, &BUSH_RIGHT_SRC }, + { CLOUD_LEFT_BOTTOM_ID, &CLOUD_LEFT_BOTTOM_SRC }, + { CLOUD_MIDDLE_BOTTOM_ID, &CLOUD_MIDDLE_BOTTOM_SRC }, + { CLOUD_RIGHT_BOTTOM_ID, &CLOUD_RIGHT_BOTTOM_SRC }, + { CLOUD_LEFT_TOP_ID, &CLOUD_LEFT_TOP_SRC }, + { CLOUD_MIDDLE_TOP_ID, &CLOUD_MIDDLE_TOP_SRC }, + { CLOUD_RIGHT_TOP_ID, &CLOUD_RIGHT_TOP_SRC }, + { PIPE_LEFT_BOTTOM_ID, &PIPE_LEFT_BOTTOM_SRC }, + { PIPE_LEFT_TOP_ID, &PIPE_LEFT_TOP_SRC }, + { PIPE_RIGHT_BOTTOM_ID, &PIPE_RIGHT_BOTTOM_SRC }, + { PIPE_RIGHT_TOP_ID, &PIPE_RIGHT_TOP_SRC }, + { CASTLE_LEFT_ID, &CASTLE_LEFT_SRC }, + { CASTLE_RIGHT_ID, &CASTLE_RIGHT_SRC }, + { CASTLE_BLACK_ID, &CASTLE_BLACK_SRC }, + { CASTLE_ENTRY_ID, &CASTLE_ENTRY_SRC }, + { CASTLE_TOWER_ID, &CASTLE_TOWER_SRC }, + { CASTLE_TOWER_FILLED_ID, &CASTLE_TOWER_FILLED_SRC }, + { VINE_TOP_ID, &VINE_TOP_SRC }, + { VINE_BOTTOM_ID, &VINE_BOTTOM_SRC }, + { POLE_TOP_ID, &POLE_TOP_SRC }, + { POLE_BOTTOM_ID, &POLE_BOTTOM_SRC }, + { FLAG_ID, &FLAG_SRC }, + { STEP_ID, &STEP_SRC }, + { BRICK_ID, &BRICK_SRC }, + { BRICK_TOP_ID, &BRICK_TOP_SRC }, + { SIDEWAY_PIPE_END_TOP_ID, &SIDEWAY_PIPE_END_TOP_SRC }, + { SIDEWAY_PIPE_END_BOTTOM_ID, &SIDEWAY_PIPE_END_BOTTOM_SRC }, + { SIDEWAY_PIPE_MIDDLE_TOP_ID, &SIDEWAY_PIPE_MIDDLE_TOP_SRC }, + { SIDEWAY_PIPE_MIDDLE_BOTTOM_ID, &SIDEWAY_PIPE_MIDDLE_BOTTOM_SRC }, + { SIDEWAY_PIPE_CONNECTOR_TOP_ID, &SIDEWAY_PIPE_CONNECTOR_TOP_SRC }, + { SIDEWAY_PIPE_CONNECTOR_BOTTOM_ID, &SIDEWAY_PIPE_CONNECTOR_BOTTOM_SRC }, + { TREE_PLATFORM_TOP_LEFT_ID, &TREE_PLATFORM_TOP_LEFT_SRC }, + { TREE_PLATFORM_TOP_MIDDLE_ID, &TREE_PLATFORM_TOP_MIDDLE_SRC }, + { TREE_PLATFORM_TOP_RIGHT_ID, &TREE_PLATFORM_TOP_RIGHT_SRC }, + { TREE_PLATFORM_BARK_ID, &TREE_PLATFORM_BARK_SRC }, + { WATER_TOP_ID, &WATER_TOP_SRC }, + { WATER_FILL_ID, &WATER_FILL_SRC }, + { MUSHROOM_PLATFORM_TOP_LEFT_ID, &MUSHROOM_PLATFORM_TOP_LEFT_SRC }, + { MUSHROOM_PLATFORM_TOP_MIDDLE_ID, &MUSHROOM_PLATFORM_TOP_MIDDLE_SRC }, + { MUSHROOM_PLATFORM_TOP_RIGHT_ID, &MUSHROOM_PLATFORM_TOP_RIGHT_SRC }, + { MUSHROOM_PLATFORM_BARK_TOP_ID, &MUSHROOM_PLATFORM_BARK_TOP_SRC }, + { MUSHROOM_PLATFORM_BARK_BOTTOM_ID, &MUSHROOM_PLATFORM_BARK_BOTTOM_SRC }, + { TREE_BARK_ID, &TREE_BARK_SRC }, + { TREE_LEAVES_SMALL_ID, &TREE_LEAVES_SMALL_SRC }, + { TREE_LEAVES_TOP_ID, &TREE_LEAVES_TOP_SRC }, + { TREE_LEAVES_BOTTOM_ID, &TREE_LEAVES_BOTTOM_SRC }, + { CANNON_TOWER_ID, &CANNON_TOWER_SRC }, + { CANNON_PEDESTAL_ID, &CANNON_PEDESTAL_SRC }, + { CANNON_ID, &CANNON_SRC }, + { MARIO_ID, &MARIO_STANDING_SRC } }; std::shared_ptr< SDLPP::RectangleRender > createBlock( std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y, std::shared_ptr< SDLPP::Texture > &texture, const SDL_Rect &src, uint64_t id, bool collision = false ) { - auto block = std::make_shared(x, y, renderer, texture, src); + auto block = std::make_shared< MarioBlock >( x, y, renderer, texture, src ); block->setId( id ); block->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); block->setStatic(); @@ -139,9 +168,9 @@ createBlock( std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y, } SDL_Rect getSourceRectByID( uint64_t id, LandType::Value type ) { - if(block_mapping.find(id) == block_mapping.end()) + if ( block_mapping.find( id ) == block_mapping.end() ) return {}; - SDL_Rect ret_src = *block_mapping.at(id); + SDL_Rect ret_src = *block_mapping.at( id ); switch ( type ) { case LandType::OVERWORLD: ret_src.x += OVERWORLD_SHIFT.getX(); @@ -162,41 +191,55 @@ SDL_Rect getSourceRectByID( uint64_t id, LandType::Value type ) { } return ret_src; } -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 ) { +std::shared_ptr< SDLPP::RectangleRender > +createTerrainBlock( uint64_t block_id, LandType::Value type, + std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y, + std::shared_ptr< SDLPP::Texture > texture, + bool collision ) { return createBlock( renderer, x, y, texture, getSourceRectByID( block_id, type ), block_id, 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, LandType::Value type, + std::shared_ptr< SDLPP::Renderer > &renderer, + std::shared_ptr< SDLPP::Texture > texture, + bool collision ) { + return createTerrainBlock( block_id, type, renderer, 0, 0, texture, + collision ); } std::shared_ptr< SDLPP::RectangleRender > 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::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, LandType::Value type, std::shared_ptr< SDLPP::Renderer > &renderer, bool collision ) { - return createTerrainBlock(block_id, type, renderer, g_terrain_texture, collision); + return createTerrainBlock( block_id, type, renderer, g_terrain_texture, + collision ); } -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); +std::shared_ptr< SDLPP::RectangleRender > +createMario( LandType::Value type, std::shared_ptr< SDLPP::Renderer > &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< MarioBlock & >( *mario ).setTerrain( false ); return mario; } -enum BlockRole::Value getBlockRole(uint64_t id) { - if(id >= 0x7000) +enum BlockRole::Value getBlockRole( uint64_t id ) { + if ( id >= 0x7000 ) return BlockRole::TERRAIN; - if(id == MARIO_ID) + if ( id == MARIO_ID ) return BlockRole::MARIO; - //TODO modifier/character + // TODO modifier/character return BlockRole::MODIFIER; } diff --git a/mario/blocks.hpp b/mario/blocks.hpp index cd5484b..70b06b5 100644 --- a/mario/blocks.hpp +++ b/mario/blocks.hpp @@ -6,24 +6,21 @@ class MarioBlock : public SDLPP::RectangleRender { public: - MarioBlock(int x, int y, std::shared_ptr renderer, std::shared_ptr texture, SDL_Rect src); + MarioBlock( int x, int y, std::shared_ptr< SDLPP::Renderer > renderer, + std::shared_ptr< SDLPP::Texture > texture, SDL_Rect src ); void visit( SDLPP::Visitor &visitor ) override; - void setTool(bool tool = true); - void setTerrain(bool terrain = true); + void setTool( bool tool = true ); + void setTerrain( bool terrain = true ); + private: bool _tool = false; bool _terrain = true; }; -extern const std::vector possibleBlocks; +extern const std::vector< uint64_t > possibleBlocks; struct LandType { - enum Value { - OVERWORLD = 0, - UNDERWORLD = 1, - WATER = 2, - BOWSER = 4 - }; + enum Value { OVERWORLD = 0, UNDERWORLD = 1, WATER = 2, BOWSER = 4 }; }; struct BlockRole { @@ -35,14 +32,30 @@ struct BlockRole { }; }; -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 ); +std::shared_ptr< SDLPP::RectangleRender > +createTerrainBlock( uint64_t block_id, LandType::Value type, + std::shared_ptr< SDLPP::Renderer > &renderer, + bool collision = false ); +std::shared_ptr< SDLPP::RectangleRender > +createTerrainBlock( uint64_t block_id, LandType::Value type, + std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y, + bool collision = false ); +std::shared_ptr< SDLPP::RectangleRender > +createTerrainBlock( uint64_t block_id, LandType::Value type, + std::shared_ptr< SDLPP::Renderer > &renderer, + std::shared_ptr< SDLPP::Texture > texture, + bool collision = false ); +std::shared_ptr< SDLPP::RectangleRender > +createTerrainBlock( uint64_t block_id, LandType::Value type, + std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y, + std::shared_ptr< SDLPP::Texture > texture, + bool collision = false ); +std::shared_ptr< SDLPP::RectangleRender > +createMario( LandType::Value type, std::shared_ptr< SDLPP::Renderer > &renderer, + int x, int y ); SDL_Rect getSourceRectByID( uint64_t id, LandType::Value type ); -enum BlockRole::Value getBlockRole(uint64_t id); +enum BlockRole::Value getBlockRole( uint64_t id ); #endif diff --git a/mario/editor.cpp b/mario/editor.cpp index b8e115f..0bf2288 100644 --- a/mario/editor.cpp +++ b/mario/editor.cpp @@ -33,85 +33,94 @@ struct MouseInfo { std::shared_ptr< SDLPP::Renderer > g_renderer = nullptr; bool g_quit = false; bool g_update_size = false; -std::vector g_objects = {}; +std::vector< mapColumnType > g_objects = {}; std::mutex g_destruction_mutex; -// current mouse flags, previous mouse flags, selected edit box, selected tool box -std::tuple, SDLPP::Vec2D> g_mouse_info; +// current mouse flags, previous mouse flags, selected edit box, selected tool +// box +std::tuple< uint64_t, uint64_t, SDLPP::Vec2D< int >, SDLPP::Vec2D< int > > + 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; +std::vector< std::shared_ptr< SDLPP::RenderObject > > g_tools{}; +std::shared_ptr< SDLPP::RenderObject > 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; +std::shared_ptr< SDLPP::Texture > g_placeholder_texture = nullptr; +std::shared_ptr< SDLPP::Texture > g_placeholder_mario = nullptr; -std::shared_ptr g_mario = nullptr; -SDLPP::Vec2D g_mario_pos = {0,0}; +std::shared_ptr< SDLPP::RenderObject > g_mario = nullptr; +SDLPP::Vec2D< int > g_mario_pos = { 0, 0 }; 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; + auto tool_role = getBlockRole( possibleBlocks[g_current_block] ); + std::shared_ptr< SDLPP::Texture > 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]); + 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) + 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_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) { +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 = 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); + 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); + updateToolSelection( g_current_tool_index + 1 ); } void moveToolsRight() { g_current_tool_index++; - updateToolSelection(g_current_tool_index - 1); + 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) + if ( g_current_block == 0 ) return; - if(g_current_block % 8 == 0) { + if ( g_current_block % 8 == 0 ) { moveToolsLeft(); } g_current_block--; @@ -119,9 +128,9 @@ void selectPrevTool() { } void selectNextTool() { - if(g_current_block == g_tools.size() - 1) + if ( g_current_block == g_tools.size() - 1 ) return; - if(g_current_block % 8 == 7) { + if ( g_current_block % 8 == 7 ) { moveToolsRight(); } g_current_block++; @@ -147,50 +156,57 @@ void handleKeyUp( SDL_Keycode key, SDLPP::Scene &scene ) { } } -void getMousePositionFlags(SDLPP::Scene &scene) { - auto mouse = scene.getObjects({EDITOR_MOUSE_ID})[0]; +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)); + mouse->setPos( SDLPP::Mouse::getMousePositionDouble( + scene.getRenderer(), SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ) ); 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(); + scene.visitCollisions( *mouse, visitor ); + std::get< MouseInfo::CUR_FLAGS >( g_mouse_info ) = visitor.getFlags(); + std::get< MouseInfo::EDIT_BOX >( g_mouse_info ) = + visitor.getEditBoxIndexes(); + std::get< MouseInfo::TOOL_BOX >( 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); + if ( visitor.foundEditBox() ) { + const auto &box = std::get< MouseInfo::EDIT_BOX >( g_mouse_info ); + g_current_tool->setPos( BLOCK_SIZE + box.getX() * BLOCK_SIZE, + 4 * BLOCK_SIZE + box.getY() * BLOCK_SIZE ); } } -void mouseUpAction(uint64_t flags, SDLPP::Scene &scene) { - if(MouseVisitor::moveMapLeft(flags) && g_current_start_index != 0) { +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); + scene.moveEverything( BLOCK_SIZE, 0 ); } - if(MouseVisitor::moveMapRight(flags)) { - if(g_current_start_index == g_current_max_index) { + 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_objects.resize( g_current_max_index + 18 + 1 ); g_current_max_index++; } g_current_start_index += 1; - scene.moveEverything(-BLOCK_SIZE,0); + scene.moveEverything( -BLOCK_SIZE, 0 ); } - if(MouseVisitor::moveToolsLeft(flags) && g_current_tool_index != 0) { + if ( MouseVisitor::moveToolsLeft( flags ) && g_current_tool_index != 0 ) { g_current_tool_index -= 1; - updateToolSelection(g_current_tool_index + 1); + updateToolSelection( g_current_tool_index + 1 ); } - if(MouseVisitor::moveToolsRight(flags) && g_current_tool_index != g_max_tool_index) { + if ( MouseVisitor::moveToolsRight( flags ) && + g_current_tool_index != g_max_tool_index ) { g_current_tool_index += 1; - updateToolSelection(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() }; +SDLPP::Vec2D< int > getSelectedObjectPosition() { + return { g_current_start_index + + std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX(), + std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getY() }; } mapObjectType &getSelectedObject() { @@ -198,69 +214,75 @@ mapObjectType &getSelectedObject() { return g_objects[pos.getX()][pos.getY()]; } -void placeTool(SDLPP::Scene &scene) { - std::lock_guard lock(g_destruction_mutex); +void placeTool( SDLPP::Scene &scene ) { + std::lock_guard< std::mutex > 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; + 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()) { + 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; + 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()) { + } 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; + 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 ) = g_current_tool->getId(); + // TODO why 1 +? + new_obj = createTerrainBlock( + g_current_tool->getId(), LandType::OVERWORLD, g_renderer, + 1 + std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX(), + std::get< MouseInfo::EDIT_BOX >( 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< MapObject::CHARACTER_TYPE >( obj ) = LandType::OVERWORLD; + // TODO character ID + 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, g_renderer, + 1 + std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX(), + std::get< MouseInfo::EDIT_BOX >( 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); + scene.addObject( new_obj ); + scene.setZIndex( new_obj, z_index ); } } @@ -280,19 +302,24 @@ void pollEvents( SDLPP::Scene &scene ) { } break; case SDL_MOUSEMOTION: - getMousePositionFlags(scene); + getMousePositionFlags( scene ); break; case SDL_MOUSEBUTTONUP: - if(std::get(g_mouse_info) == std::get(g_mouse_info)) { - mouseUpAction(std::get(g_mouse_info), scene); + if ( std::get< MouseInfo::CUR_FLAGS >( g_mouse_info ) == + std::get< MouseInfo::PREV_FLAGS >( g_mouse_info ) ) { + mouseUpAction( std::get< MouseInfo::CUR_FLAGS >( g_mouse_info ), + scene ); } - if(std::get(g_mouse_info).getX() != -1) { - placeTool(scene); + if ( std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX() != + -1 ) { + placeTool( scene ); } - if(std::get(g_mouse_info).getX() != -1) { - auto &tool_box = std::get(g_mouse_info); + if ( std::get< MouseInfo::TOOL_BOX >( g_mouse_info ).getX() != + -1 ) { + auto &tool_box = + std::get< MouseInfo::TOOL_BOX >( g_mouse_info ); size_t index = tool_box.getY() * 4 + tool_box.getX(); - if(index < g_tools.size()) { + if ( index < g_tools.size() ) { g_current_block = g_current_tool_index * 8 + index; updateTool(); } @@ -300,7 +327,8 @@ void pollEvents( SDLPP::Scene &scene ) { break; case SDL_MOUSEBUTTONDOWN: // store current mouse flags in previous mouse flags - std::get(g_mouse_info) = std::get(g_mouse_info); + std::get< MouseInfo::PREV_FLAGS >( g_mouse_info ) = + std::get< MouseInfo::CUR_FLAGS >( g_mouse_info ); break; default: break; @@ -351,159 +379,180 @@ int main() { // 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, g_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) { + 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, g_renderer, "#282828" ); line_horizontal->setPermanent(); - line_horizontal->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); - scene->addObject(line_horizontal); + line_horizontal->setAlignment( SDLPP::OBJ_CENTER, + SDLPP::OBJ_CENTER ); + scene->addObject( line_horizontal ); } } // white rectangles auto rectangle1 = std::make_shared< SDLPP::RectangleRender >( - 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); + 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(); - rectangle1->addCollision(SDLPP::RectColider(0, 0, 1, 1)); - scene->addObject(rectangle1); + rectangle1->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) ); + scene->addObject( rectangle1 ); // white rectangles auto rectangle2 = std::make_shared< SDLPP::RectangleRender >( - 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); + 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(); - rectangle2->addCollision(SDLPP::RectColider(0, 0, 1, 1)); - scene->addObject(rectangle2); + 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 >( - 0, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, "<", font_config); - left->setId(0); - left->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); + 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); + scene->addObject( left ); auto right = std::make_shared< SDLPP::TextRenderer >( - 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); + 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(); - scene->addObject(right); + scene->addObject( right ); - for(int i = 0; i < 18; i++) { - for(int j = 0; j < 16; j++) { - scene->addObject(std::make_shared(i, j, g_renderer)); + for ( int i = 0; i < 18; i++ ) { + for ( int j = 0; j < 16; j++ ) { + scene->addObject( std::make_shared< EditBox >( i, j, g_renderer ) ); } } - auto mouse = - std::make_shared< SDLPP::RectangleRender >( 0.01, 0.01, 0, 0, g_renderer ); - mouse->setMinWidth(1); - mouse->setMinHeight(1); + auto mouse = 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 ); mouse->setId( EDITOR_MOUSE_ID ); - mouse->setColiderColor("#00FF00"); - mouse->addCollision( - SDLPP::RectColider( { 0, 0 }, { 1, 1 } ) ); + mouse->setColiderColor( "#00FF00" ); + mouse->addCollision( SDLPP::RectColider( { 0, 0 }, { 1, 1 } ) ); scene->addObject( mouse ); g_current_max_index = g_objects.size() - 18; // tools - g_max_tool_index = (possibleBlocks.size() - 1) / 8; - for(int i = 0; i < 4; i++) { - 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; -// std::cout << "TOOL BOX POS: " << tool_box2->getPos().getX() << ", " << tool_box2->getPos().getY() << std::endl; + g_max_tool_index = ( possibleBlocks.size() - 1 ) / 8; + for ( int i = 0; i < 4; i++ ) { + auto tool_box1 = std::make_shared< ToolBox >( i, 0, g_renderer ); + auto tool_box2 = std::make_shared< ToolBox >( 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; std::cout << + // "TOOL BOX POS: " << tool_box2->getPos().getX() << ", " << + // tool_box2->getPos().getY() << std::endl; } int tool_index = 0; - for(auto &block : possibleBlocks) { - if(block == MARIO_ID ) { - g_tools.push_back(createMario(LandType::OVERWORLD, g_renderer, 0, 0)); + for ( auto &block : possibleBlocks ) { + if ( block == MARIO_ID ) { + g_tools.push_back( + createMario( LandType::OVERWORLD, g_renderer, 0, 0 ) ); } else { - g_tools.push_back(createTerrainBlock(block, LandType::OVERWORLD, g_renderer, false)); + g_tools.push_back( createTerrainBlock( block, LandType::OVERWORLD, + g_renderer, false ) ); } - g_tools.back()->setHidden(true); + 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 - 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(g_tools.back()); - tool_index = (tool_index + 1) % 8; + 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( 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, g_renderer, "#282828"); + for ( int i = 0; i < 5; i++ ) { + auto line = std::make_shared< SDLPP::LineRenderer >( + 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); + 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, g_renderer, "#282828"); + for ( int i = 0; i < 3; i++ ) { + auto line = std::make_shared< SDLPP::LineRenderer >( + 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); + 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, g_renderer, "#FFFFFF88", true); - tool_rect1->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); - tool_rect1->setId(EDITOR_LEFT_TOOL_ID); + 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(); - tool_rect1->addCollision(SDLPP::RectColider(0, 0, 1, 1)); - scene->addObject(tool_rect1); + tool_rect1->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) ); + 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, g_renderer, "#FFFFFF88", true); - tool_rect2->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); - tool_rect2->setId(EDITOR_RIGHT_TOOL_ID); + 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); + 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, g_renderer, "<", font_config); - left_tool->setId(0); - left_tool->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); + 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); + scene->addObject( left_tool ); auto right_tool = std::make_shared< SDLPP::TextRenderer >( - 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); + 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); + scene->addObject( right_tool ); g_placeholder_texture = std::make_shared< SDLPP::Texture >( g_renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); - g_placeholder_texture->setAlpha(100); + g_placeholder_texture->setAlpha( 100 ); g_placeholder_mario = std::make_shared< SDLPP::Texture >( g_renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); - g_placeholder_mario->setAlpha(100); - 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); + g_placeholder_mario->setAlpha( 100 ); + 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< MarioBlock & >( *g_current_tool ).setTool(); + scene->addObject( g_current_tool ); + scene->moveZTop( g_current_tool ); - scene->moveEverything(BLOCK_SIZE, 0); + scene->moveEverything( BLOCK_SIZE, 0 ); FPSmanager gFPS; SDL_initFramerate( &gFPS ); SDL_setFramerate( &gFPS, 60 ); - updateToolSelection(0); + updateToolSelection( 0 ); auto base = SDL_GetTicks(); int frames = 0; @@ -512,7 +561,7 @@ int main() { while ( !g_quit ) { SDL_PumpEvents(); SDL_framerateDelay( &gFPS ); - std::lock_guard lock(g_destruction_mutex); + std::lock_guard< std::mutex > lock( g_destruction_mutex ); scene->renderScene(); g_renderer->presentRenderer(); frames++; @@ -521,33 +570,33 @@ int main() { frames = 0; base = SDL_GetTicks(); } - if(g_current_start_index == 0) { - left->setTextColor(font, "#CCCCCC", "#CCCCCC", 0.05); + if ( g_current_start_index == 0 ) { + left->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 ); } else { - left->setTextColor(font, "#000000", "#282828", 0.05); + left->setTextColor( font, "#000000", "#282828", 0.05 ); } - if(g_current_start_index == g_current_max_index) { - right->setTextColor(font, "#00FF00", "#000000", 0.1); - right->changeText("+"); + 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(">"); + right->setTextColor( font, "#000000", "#282828", 0.05 ); + right->changeText( ">" ); } - if(g_current_tool_index == 0) { - left_tool->setTextColor(font, "#CCCCCC", "#CCCCCC", 0.05); + if ( g_current_tool_index == 0 ) { + left_tool->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 ); } else { - left_tool->setTextColor(font, "#000000", "#282828", 0.05); + left_tool->setTextColor( font, "#000000", "#282828", 0.05 ); } - if(g_current_tool_index == g_max_tool_index) { - right_tool->setTextColor(font, "#CCCCCC", "#CCCCCC", 0.05); + 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); + right_tool->setTextColor( font, "#000000", "#282828", 0.05 ); } - if(g_update_size) { + if ( g_update_size ) { scene->updateSizeAndPosition(); } } - saveMap("test_binary2.bin", g_objects); + saveMap( "test_binary2.bin", g_objects ); return 0; } diff --git a/mario/editor_visitor.cpp b/mario/editor_visitor.cpp index 7d06a0f..e229b80 100644 --- a/mario/editor_visitor.cpp +++ b/mario/editor_visitor.cpp @@ -30,30 +30,30 @@ void MouseVisitor::visit( const SDLPP::RenderObject &obj ) { break; case EDITOR_EDIT_SQUARE: edit_box = true; - edit_box_location = dynamic_cast(obj).getIndexes(); + edit_box_location = dynamic_cast< const EditBox & >( obj ).getIndexes(); break; case EDITOR_TOOL_ID: tool_box = true; - tool_box_location = dynamic_cast(obj).getIndexes(); + tool_box_location = dynamic_cast< const ToolBox & >( obj ).getIndexes(); break; default: break; } } -bool MouseVisitor::moveMapLeft(uint64_t flags) { +bool MouseVisitor::moveMapLeft( uint64_t flags ) { return flags & SELECTED_LEFT_MAP; } -bool MouseVisitor::moveMapRight(uint64_t flags) { +bool MouseVisitor::moveMapRight( uint64_t flags ) { return flags & SELECTED_RIGHT_MAP; } -bool MouseVisitor::moveToolsLeft(uint64_t flags) { +bool MouseVisitor::moveToolsLeft( uint64_t flags ) { return flags & SELECTED_LEFT_TOOL; } -bool MouseVisitor::moveToolsRight(uint64_t flags) { +bool MouseVisitor::moveToolsRight( uint64_t flags ) { return flags & SELECTED_RIGHT_TOOL; } @@ -62,12 +62,14 @@ void ToolVisitor::visit( const SDLPP::RenderObject &obj ) { switch ( id ) { case EDITOR_TERRAIN_ID: remove_block = true; - if(obj.getId() == source_id && getVisitorType() == VisitorType::Terrain) { + if ( obj.getId() == source_id && + getVisitorType() == VisitorType::Terrain ) { add_block = false; } case EDITOR_CHARACTER_ID: remove_block = true; - if(obj.getId() == source_id && getVisitorType() == VisitorType::Modifier) { + 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 3d06849..ed800b6 100644 --- a/mario/editor_visitor.hpp +++ b/mario/editor_visitor.hpp @@ -17,20 +17,22 @@ public: MouseVisitor() {} virtual void visit( const SDLPP::RenderObject &obj ) override; virtual void setFromId( uint64_t /*UNUSED*/ ) override {} - virtual uint64_t getFromId() override {return 0;} + virtual uint64_t getFromId() override { + return 0; + } uint64_t getFlags() { return select_flags; } bool foundEditBox() { return edit_box; } - const SDLPP::Vec2D &getEditBoxIndexes() { + const SDLPP::Vec2D< int > &getEditBoxIndexes() { return edit_box_location; } bool foundToolBox() { return tool_box; } - const SDLPP::Vec2D &getToolBoxIndexes() { + const SDLPP::Vec2D< int > &getToolBoxIndexes() { return tool_box_location; } virtual void setVisitorType( uint64_t type ) override { @@ -40,23 +42,23 @@ public: return _type; } - static bool moveMapLeft(uint64_t flags); - static bool moveMapRight(uint64_t flags); - static bool moveToolsLeft(uint64_t flags); - static bool moveToolsRight(uint64_t flags); + static bool moveMapLeft( uint64_t flags ); + static bool moveMapRight( uint64_t flags ); + static bool moveToolsLeft( uint64_t flags ); + static bool moveToolsRight( uint64_t flags ); private: uint64_t select_flags = 0; bool edit_box = false; bool tool_box = false; - SDLPP::Vec2D edit_box_location = {-1, -1}; - SDLPP::Vec2D tool_box_location = {-1, -1}; + SDLPP::Vec2D< int > edit_box_location = { -1, -1 }; + SDLPP::Vec2D< int > tool_box_location = { -1, -1 }; uint64_t _type; }; class ToolVisitor : public SDLPP::Visitor { public: - ToolVisitor() {}; + ToolVisitor(){}; virtual void visit( const SDLPP::RenderObject &obj ) override; virtual void setFromId( uint64_t id ) override { source_id = id; diff --git a/mario/maploader.cpp b/mario/maploader.cpp index a3aed0f..ea045c0 100644 --- a/mario/maploader.cpp +++ b/mario/maploader.cpp @@ -7,126 +7,149 @@ #include "objectids.hpp" // TODO move to one function -void loadMap(std::shared_ptr &scene, std::shared_ptr mario, const std::string &file, std::shared_ptr &renderer) { +void loadMap( std::shared_ptr< SDLPP::Scene > &scene, + std::shared_ptr< SDLPP::RectangleRender > mario, + const std::string &file, + std::shared_ptr< SDLPP::Renderer > &renderer ) { std::ifstream map_file; - map_file.open(file, std::ios::in | std::ios::binary); + map_file.open( file, std::ios::in | std::ios::binary ); uint16_t cols; - map_file.read((char*)&cols, sizeof(uint16_t)/sizeof(char)); - for(uint16_t i = 0; i < cols; i++) { - for(int j = 0; j < 16; j++) { + map_file.read( ( char * )&cols, sizeof( uint16_t ) / sizeof( char ) ); + for ( uint16_t i = 0; i < cols; i++ ) { + for ( int j = 0; j < 16; j++ ) { uint16_t input_number; uint8_t additional_data = 0; - uint8_t character_type = 0, character = 0, modifier_type = 0, modifier_data = 0; - map_file.read((char *)&input_number, sizeof(uint16_t)/sizeof(char)); - uint8_t type = (input_number & 0xF000)>>12; - uint16_t id = (input_number & 0x0FFF) | BLOCK_PREFIX; - if(type & 0x8) { - map_file.read((char *)&additional_data, sizeof(uint8_t)/sizeof(char)); + uint8_t character_type = 0, character = 0, modifier_type = 0, + modifier_data = 0; + map_file.read( ( char * )&input_number, + sizeof( uint16_t ) / sizeof( char ) ); + uint8_t type = ( input_number & 0xF000 ) >> 12; + uint16_t id = ( input_number & 0x0FFF ) | BLOCK_PREFIX; + if ( type & 0x8 ) { + map_file.read( ( char * )&additional_data, + sizeof( uint8_t ) / sizeof( char ) ); type &= ~0x8; - if(additional_data & 0x80) { - //modifier + if ( additional_data & 0x80 ) { + // modifier additional_data &= ~0x80; - modifier_type = (additional_data & 0xF0)>>4; + modifier_type = ( additional_data & 0xF0 ) >> 4; modifier_data = additional_data & 0x0F; } else { // character - character_type = (additional_data & 0xF0)>>4; + character_type = ( additional_data & 0xF0 ) >> 4; character = additional_data & 0x0F; } } bool collision = false; - if(id == FLOOR_ID) { + if ( id == FLOOR_ID ) { collision = true; } // TODO add modifiers to createTerrainBlock - auto obj = createTerrainBlock(id, static_cast(type), renderer, i, j, collision); - if(obj != nullptr) - scene->addObject(obj); - if(character) { - if(character == MARIO_ID) { - mario->setPos(i * BLOCK_SIZE, 1 - (16-j) * BLOCK_SIZE); + auto obj = + createTerrainBlock( id, static_cast< LandType::Value >( type ), + renderer, i, j, collision ); + if ( obj != nullptr ) + scene->addObject( obj ); + if ( character ) { + if ( character == MARIO_ID ) { + mario->setPos( i * BLOCK_SIZE, + 1 - ( 16 - j ) * BLOCK_SIZE ); } } } } - scene->moveZTop(mario); + scene->moveZTop( mario ); } // editor loader -void loadMap(std::shared_ptr &scene, const std::string &file, std::shared_ptr &renderer, std::vector &objects) { +void loadMap( std::shared_ptr< SDLPP::Scene > &scene, const std::string &file, + std::shared_ptr< SDLPP::Renderer > &renderer, + std::vector< mapColumnType > &objects ) { std::ifstream map_file; - map_file.open(file, std::ios::in | std::ios::binary); + map_file.open( file, std::ios::in | std::ios::binary ); uint16_t cols; - map_file.read((char*)&cols, sizeof(uint16_t)/sizeof(char)); - objects.resize(cols); - for(uint16_t i = 0; i < cols; i++) { + map_file.read( ( char * )&cols, sizeof( uint16_t ) / sizeof( char ) ); + objects.resize( cols ); + for ( uint16_t i = 0; i < cols; i++ ) { auto &col = objects[i]; - for(int j = 0; j < 16; j++) { + for ( int j = 0; j < 16; j++ ) { uint16_t input_number; uint8_t additional_data = 0; - uint8_t character_type = 0, character = 0, modifier_type = 0, modifier_data = 0; - map_file.read((char *)&input_number, sizeof(uint16_t)/sizeof(char)); - uint8_t type = (input_number & 0xF000)>>12; - uint16_t id = (input_number & 0x0FFF) | BLOCK_PREFIX; - if(type & 0x8) { - map_file.read((char *)&additional_data, sizeof(uint8_t)/sizeof(char)); + uint8_t character_type = 0, character = 0, modifier_type = 0, + modifier_data = 0; + map_file.read( ( char * )&input_number, + sizeof( uint16_t ) / sizeof( char ) ); + uint8_t type = ( input_number & 0xF000 ) >> 12; + uint16_t id = ( input_number & 0x0FFF ) | BLOCK_PREFIX; + if ( type & 0x8 ) { + map_file.read( ( char * )&additional_data, + sizeof( uint8_t ) / sizeof( char ) ); type &= ~0x8; - if(additional_data & 0x80) { - //modifier + if ( additional_data & 0x80 ) { + // modifier additional_data &= ~0x80; - modifier_type = (additional_data & 0xF0)>>4; + modifier_type = ( additional_data & 0xF0 ) >> 4; modifier_data = additional_data & 0x0F; } else { // character - character_type = (additional_data & 0xF0)>>4; + character_type = ( additional_data & 0xF0 ) >> 4; character = additional_data & 0x0F; } } - col[j] = {type, id, character_type, character, modifier_type, modifier_data}; + 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); - 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)); + auto obj = + createTerrainBlock( id, static_cast< LandType::Value >( 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< LandType::Value >( character_type ), + renderer, i, j ) ); } } } } - if(objects.size() < 18) { - objects.resize(18); + if ( objects.size() < 18 ) { + objects.resize( 18 ); } } -// tuple - world object type, object, world character type, character, modifier type, modifier data -void saveMap(const std::string &file, std::vector &objects) { +// tuple - world object type, object, world character type, character, modifier +// type, modifier data +void saveMap( const std::string &file, std::vector< mapColumnType > &objects ) { std::ofstream output_file; - output_file.open(file, std::ios::out | std::ios::binary); + output_file.open( file, std::ios::out | std::ios::binary ); uint16_t cols = objects.size(); - output_file.write((char*)&cols, sizeof(uint16_t)/sizeof(char)); - for(auto &col : objects) { - for(int i = 0; i < 16; i++) { + output_file.write( ( char * )&cols, sizeof( uint16_t ) / sizeof( char ) ); + for ( auto &col : objects ) { + for ( int i = 0; i < 16; i++ ) { auto &obj = col[i]; - uint16_t wide_type = std::get<0>(obj); - wide_type = wide_type<<12; - uint16_t write_num = (0x0FFF & std::get<1>(obj)) | wide_type; - // 3 becuase character type can be 0 (overworld), 4 because modifier data can be 0 (breakable) - if(std::get<3>(obj) || std::get<4>(obj)) { + uint16_t wide_type = std::get< 0 >( obj ); + wide_type = wide_type << 12; + uint16_t write_num = ( 0x0FFF & std::get< 1 >( obj ) ) | wide_type; + // 3 becuase character type can be 0 (overworld), 4 because modifier + // data can be 0 (breakable) + if ( std::get< 3 >( obj ) || std::get< 4 >( obj ) ) { write_num |= 0x8000; } - output_file.write((char*)&write_num, sizeof(uint16_t)/sizeof(char)); + output_file.write( ( char * )&write_num, + sizeof( uint16_t ) / sizeof( char ) ); uint8_t additional_data = 0; - if(std::get<3>(obj)) { - additional_data |= std::get<2>(obj)<<4; - additional_data |= std::get<3>(obj); - } else if(std::get<4>(obj)) { - additional_data |= std::get<4>(obj)<<4; + if ( std::get< 3 >( obj ) ) { + additional_data |= std::get< 2 >( obj ) << 4; + additional_data |= std::get< 3 >( obj ); + } else if ( std::get< 4 >( obj ) ) { + additional_data |= std::get< 4 >( obj ) << 4; additional_data |= 0x80; - additional_data |= std::get<5>(obj); + additional_data |= std::get< 5 >( obj ); } - if(additional_data) { - output_file.write((char*)&additional_data, sizeof(uint8_t)/sizeof(char)); + if ( additional_data ) { + output_file.write( ( char * )&additional_data, + sizeof( uint8_t ) / sizeof( char ) ); } } } diff --git a/mario/maploader.hpp b/mario/maploader.hpp index 0c9fbc4..31f533d 100644 --- a/mario/maploader.hpp +++ b/mario/maploader.hpp @@ -15,11 +15,17 @@ struct MapObject { }; }; -typedef std::tuple mapObjectType; -typedef std::array mapColumnType; +typedef std::tuple< uint8_t, uint16_t, uint8_t, uint8_t, uint8_t, uint8_t > + mapObjectType; +typedef std::array< mapObjectType, 16 > 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 &objects); -void saveMap(const std::string &file, std::vector &objects); +void loadMap( std::shared_ptr< SDLPP::Scene > &scene, + std::shared_ptr< SDLPP::RectangleRender > mario, + const std::string &file, + std::shared_ptr< SDLPP::Renderer > &renderer ); +void loadMap( std::shared_ptr< SDLPP::Scene > &scene, const std::string &file, + std::shared_ptr< SDLPP::Renderer > &renderer, + std::vector< mapColumnType > &objects ); +void saveMap( const std::string &file, std::vector< mapColumnType > &objects ); #endif diff --git a/mario/objectids.hpp b/mario/objectids.hpp index ccafbfa..81d7003 100644 --- a/mario/objectids.hpp +++ b/mario/objectids.hpp @@ -64,7 +64,6 @@ // modifiers - // character IDs #define MARIO_ID 0x0F