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

Mario editor: formatting

Browse Source
This commit is contained in:
zv0n 2021-05-09 00:46:10 +02:00
parent b54ba5034c
commit 83cda5f860
8 changed files with 595 additions and 458 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
mario/blocks.cpp
View File

@ -5,12 +5,19 @@
#include "editor_visitor.hpp" #include "editor_visitor.hpp"
#include <unordered_map> #include <unordered_map>
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 ) {} 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 ) { void MarioBlock::visit( SDLPP::Visitor &visitor ) {
if(!_tool && _terrain && visitor.getVisitorType() == VisitorType::Terrain) { if ( !_tool && _terrain &&
visitor.getVisitorType() == VisitorType::Terrain ) {
destroy(); destroy();
} }
if(!_tool && !_terrain && visitor.getVisitorType() == VisitorType::Modifier) { if ( !_tool && !_terrain &&
visitor.getVisitorType() == VisitorType::Modifier ) {
destroy(); destroy();
} }
visitor.visit( *this ); visitor.visit( *this );
@ -22,7 +29,8 @@ void MarioBlock::setTerrain(bool terrain) {
_terrain = terrain; _terrain = terrain;
} }
const std::vector< uint64_t > possibleBlocks = { FLOOR_ID, const std::vector< uint64_t > possibleBlocks = {
FLOOR_ID,
STEP_ID, STEP_ID,
HILL_TOP_ID, HILL_TOP_ID,
HILL_DOTS_LEFT_ID, HILL_DOTS_LEFT_ID,
@ -85,22 +93,40 @@ const std::vector< uint64_t > possibleBlocks = { FLOOR_ID,
}; };
const std::unordered_map< uint64_t, const SDL_Rect * > block_mapping = { const std::unordered_map< uint64_t, const SDL_Rect * > block_mapping = {
{FLOOR_ID, &FLOOR_SRC}, {HILL_INCLINE_ID, &HILL_INCLINE_SRC}, { FLOOR_ID, &FLOOR_SRC },
{HILL_DECLINE_ID, &HILL_DECLINE_SRC}, {HILL_DOTS_RIGHT_ID, &HILL_DOTS_RIGHT_SRC}, { HILL_INCLINE_ID, &HILL_INCLINE_SRC },
{HILL_DOTS_LEFT_ID, &HILL_DOTS_LEFT_SRC}, {HILL_FILL_ID, &HILL_FILL_SRC}, { HILL_DECLINE_ID, &HILL_DECLINE_SRC },
{HILL_TOP_ID, &HILL_TOP_SRC}, {BUSH_LEFT_ID, &BUSH_LEFT_SRC}, {BUSH_MIDDLE_ID, &BUSH_MIDDLE_SRC}, { HILL_DOTS_RIGHT_ID, &HILL_DOTS_RIGHT_SRC },
{BUSH_RIGHT_ID, &BUSH_RIGHT_SRC}, {CLOUD_LEFT_BOTTOM_ID, &CLOUD_LEFT_BOTTOM_SRC}, { HILL_DOTS_LEFT_ID, &HILL_DOTS_LEFT_SRC },
{CLOUD_MIDDLE_BOTTOM_ID, &CLOUD_MIDDLE_BOTTOM_SRC}, {CLOUD_RIGHT_BOTTOM_ID, &CLOUD_RIGHT_BOTTOM_SRC}, { HILL_FILL_ID, &HILL_FILL_SRC },
{CLOUD_LEFT_TOP_ID, &CLOUD_LEFT_TOP_SRC}, {CLOUD_MIDDLE_TOP_ID, &CLOUD_MIDDLE_TOP_SRC}, { HILL_TOP_ID, &HILL_TOP_SRC },
{CLOUD_RIGHT_TOP_ID, &CLOUD_RIGHT_TOP_SRC}, {PIPE_LEFT_BOTTOM_ID, &PIPE_LEFT_BOTTOM_SRC}, { BUSH_LEFT_ID, &BUSH_LEFT_SRC },
{PIPE_LEFT_TOP_ID, &PIPE_LEFT_TOP_SRC}, {PIPE_RIGHT_BOTTOM_ID, &PIPE_RIGHT_BOTTOM_SRC}, { BUSH_MIDDLE_ID, &BUSH_MIDDLE_SRC },
{PIPE_RIGHT_TOP_ID, &PIPE_RIGHT_TOP_SRC}, {CASTLE_LEFT_ID, &CASTLE_LEFT_SRC}, { BUSH_RIGHT_ID, &BUSH_RIGHT_SRC },
{CASTLE_RIGHT_ID, &CASTLE_RIGHT_SRC}, {CASTLE_BLACK_ID, &CASTLE_BLACK_SRC}, { CLOUD_LEFT_BOTTOM_ID, &CLOUD_LEFT_BOTTOM_SRC },
{CASTLE_ENTRY_ID, &CASTLE_ENTRY_SRC}, {CASTLE_TOWER_ID, &CASTLE_TOWER_SRC}, { CLOUD_MIDDLE_BOTTOM_ID, &CLOUD_MIDDLE_BOTTOM_SRC },
{CASTLE_TOWER_FILLED_ID, &CASTLE_TOWER_FILLED_SRC}, {VINE_TOP_ID, &VINE_TOP_SRC}, { CLOUD_RIGHT_BOTTOM_ID, &CLOUD_RIGHT_BOTTOM_SRC },
{VINE_BOTTOM_ID, &VINE_BOTTOM_SRC}, {POLE_TOP_ID, &POLE_TOP_SRC}, { CLOUD_LEFT_TOP_ID, &CLOUD_LEFT_TOP_SRC },
{POLE_BOTTOM_ID, &POLE_BOTTOM_SRC}, {FLAG_ID, &FLAG_SRC}, { CLOUD_MIDDLE_TOP_ID, &CLOUD_MIDDLE_TOP_SRC },
{STEP_ID, &STEP_SRC}, {BRICK_ID, &BRICK_SRC}, {BRICK_TOP_ID, &BRICK_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_TOP_ID, &SIDEWAY_PIPE_END_TOP_SRC },
{ SIDEWAY_PIPE_END_BOTTOM_ID, &SIDEWAY_PIPE_END_BOTTOM_SRC }, { SIDEWAY_PIPE_END_BOTTOM_ID, &SIDEWAY_PIPE_END_BOTTOM_SRC },
{ SIDEWAY_PIPE_MIDDLE_TOP_ID, &SIDEWAY_PIPE_MIDDLE_TOP_SRC }, { SIDEWAY_PIPE_MIDDLE_TOP_ID, &SIDEWAY_PIPE_MIDDLE_TOP_SRC },
@ -111,18 +137,21 @@ const std::unordered_map<uint64_t, const SDL_Rect*> block_mapping = {
{ TREE_PLATFORM_TOP_MIDDLE_ID, &TREE_PLATFORM_TOP_MIDDLE_SRC }, { TREE_PLATFORM_TOP_MIDDLE_ID, &TREE_PLATFORM_TOP_MIDDLE_SRC },
{ TREE_PLATFORM_TOP_RIGHT_ID, &TREE_PLATFORM_TOP_RIGHT_SRC }, { TREE_PLATFORM_TOP_RIGHT_ID, &TREE_PLATFORM_TOP_RIGHT_SRC },
{ TREE_PLATFORM_BARK_ID, &TREE_PLATFORM_BARK_SRC }, { TREE_PLATFORM_BARK_ID, &TREE_PLATFORM_BARK_SRC },
{WATER_TOP_ID, &WATER_TOP_SRC}, {WATER_FILL_ID, &WATER_FILL_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_LEFT_ID, &MUSHROOM_PLATFORM_TOP_LEFT_SRC },
{ MUSHROOM_PLATFORM_TOP_MIDDLE_ID, &MUSHROOM_PLATFORM_TOP_MIDDLE_SRC }, { MUSHROOM_PLATFORM_TOP_MIDDLE_ID, &MUSHROOM_PLATFORM_TOP_MIDDLE_SRC },
{ MUSHROOM_PLATFORM_TOP_RIGHT_ID, &MUSHROOM_PLATFORM_TOP_RIGHT_SRC }, { MUSHROOM_PLATFORM_TOP_RIGHT_ID, &MUSHROOM_PLATFORM_TOP_RIGHT_SRC },
{ MUSHROOM_PLATFORM_BARK_TOP_ID, &MUSHROOM_PLATFORM_BARK_TOP_SRC }, { MUSHROOM_PLATFORM_BARK_TOP_ID, &MUSHROOM_PLATFORM_BARK_TOP_SRC },
{ MUSHROOM_PLATFORM_BARK_BOTTOM_ID, &MUSHROOM_PLATFORM_BARK_BOTTOM_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_BARK_ID, &TREE_BARK_SRC },
{ TREE_LEAVES_SMALL_ID, &TREE_LEAVES_SMALL_SRC },
{ TREE_LEAVES_TOP_ID, &TREE_LEAVES_TOP_SRC }, { TREE_LEAVES_TOP_ID, &TREE_LEAVES_TOP_SRC },
{ TREE_LEAVES_BOTTOM_ID, &TREE_LEAVES_BOTTOM_SRC }, { TREE_LEAVES_BOTTOM_ID, &TREE_LEAVES_BOTTOM_SRC },
{ CANNON_TOWER_ID, &CANNON_TOWER_SRC }, { CANNON_TOWER_ID, &CANNON_TOWER_SRC },
{ CANNON_PEDESTAL_ID, &CANNON_PEDESTAL_SRC }, { CANNON_PEDESTAL_ID, &CANNON_PEDESTAL_SRC },
{CANNON_ID, &CANNON_SRC}, {MARIO_ID, &MARIO_STANDING_SRC} { CANNON_ID, &CANNON_SRC },
{ MARIO_ID, &MARIO_STANDING_SRC }
}; };
std::shared_ptr< SDLPP::RectangleRender > std::shared_ptr< SDLPP::RectangleRender >
@ -162,32 +191,46 @@ SDL_Rect getSourceRectByID( uint64_t id, LandType::Value type ) {
} }
return ret_src; return ret_src;
} }
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 ) { 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, return createBlock( renderer, x, y, texture,
getSourceRectByID( block_id, type ), block_id, getSourceRectByID( block_id, type ), block_id,
collision ); 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 ) { std::shared_ptr< SDLPP::RectangleRender >
return createTerrainBlock( block_id, type, renderer, 0, 0, texture, collision ); 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 > std::shared_ptr< SDLPP::RectangleRender >
createTerrainBlock( uint64_t block_id, LandType::Value type, createTerrainBlock( uint64_t block_id, LandType::Value type,
std::shared_ptr< SDLPP::Renderer > &renderer, int x, std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y,
int y, bool collision ) { bool collision ) {
return createTerrainBlock(block_id, type, renderer, x, y, g_terrain_texture, collision); return createTerrainBlock( block_id, type, renderer, x, y,
g_terrain_texture, collision );
} }
std::shared_ptr< SDLPP::RectangleRender > std::shared_ptr< SDLPP::RectangleRender >
createTerrainBlock( uint64_t block_id, LandType::Value type, createTerrainBlock( uint64_t block_id, LandType::Value type,
std::shared_ptr< SDLPP::Renderer > &renderer, std::shared_ptr< SDLPP::Renderer > &renderer,
bool collision ) { 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<SDLPP::RectangleRender> createMario( LandType::Value type, std::shared_ptr<SDLPP::Renderer> &renderer, int x, int y ) { std::shared_ptr< SDLPP::RectangleRender >
createMario( LandType::Value type, std::shared_ptr< SDLPP::Renderer > &renderer,
int x, int y ) {
// TODO add type additions // TODO add type additions
auto mario = createBlock( renderer, x, y, g_mario_texture, MARIO_STANDING_SRC, MARIO_ID, true ); auto mario = createBlock( renderer, x, y, g_mario_texture,
MARIO_STANDING_SRC, MARIO_ID, true );
dynamic_cast< MarioBlock & >( *mario ).setTerrain( false ); dynamic_cast< MarioBlock & >( *mario ).setTerrain( false );
return mario; return mario;
} }

37
mario/blocks.hpp
View File

@ -6,10 +6,12 @@
class MarioBlock : public SDLPP::RectangleRender { class MarioBlock : public SDLPP::RectangleRender {
public: public:
MarioBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> renderer, std::shared_ptr<SDLPP::Texture> 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 visit( SDLPP::Visitor &visitor ) override;
void setTool( bool tool = true ); void setTool( bool tool = true );
void setTerrain( bool terrain = true ); void setTerrain( bool terrain = true );
private: private:
bool _tool = false; bool _tool = false;
bool _terrain = true; bool _terrain = true;
@ -18,12 +20,7 @@ private:
extern const std::vector< uint64_t > possibleBlocks; extern const std::vector< uint64_t > possibleBlocks;
struct LandType { struct LandType {
enum Value { enum Value { OVERWORLD = 0, UNDERWORLD = 1, WATER = 2, BOWSER = 4 };
OVERWORLD = 0,
UNDERWORLD = 1,
WATER = 2,
BOWSER = 4
};
}; };
struct BlockRole { struct BlockRole {
@ -35,11 +32,27 @@ struct BlockRole {
}; };
}; };
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 >
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 ); createTerrainBlock( uint64_t block_id, LandType::Value type,
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::Renderer > &renderer,
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 ); bool collision = false );
std::shared_ptr<SDLPP::RectangleRender> createMario( LandType::Value type, std::shared_ptr<SDLPP::Renderer> &renderer, int x, int y ); 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 ); SDL_Rect getSourceRectByID( uint64_t id, LandType::Value type );

137
mario/editor.cpp
View File

@ -36,8 +36,10 @@ bool g_update_size = false;
std::vector< mapColumnType > g_objects = {}; std::vector< mapColumnType > g_objects = {};
std::mutex g_destruction_mutex; std::mutex g_destruction_mutex;
// current mouse flags, previous mouse flags, selected edit box, selected tool box // current mouse flags, previous mouse flags, selected edit box, selected tool
std::tuple<uint64_t, uint64_t, SDLPP::Vec2D<int>, SDLPP::Vec2D<int>> g_mouse_info; // 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_start_index = 0;
int g_current_max_index = 0; int g_current_max_index = 0;
@ -71,9 +73,12 @@ void updateTool() {
case BlockRole::CHARACTER: case BlockRole::CHARACTER:
break; break;
} }
g_current_tool->setTexture(target_texture, getSourceRectByID(possibleBlocks[g_current_block], g_current_world_type)); 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->setId( possibleBlocks[g_current_block] );
g_current_tool->getCollisions()[0]->setId(possibleBlocks[g_current_block]); g_current_tool->getCollisions()[0]->setId(
possibleBlocks[g_current_block] );
} }
void removeMario() { void removeMario() {
@ -81,17 +86,21 @@ void removeMario() {
return; return;
auto prev = g_objects[g_mario_pos.getX()][g_mario_pos.getY()]; auto prev = g_objects[g_mario_pos.getX()][g_mario_pos.getY()];
// remove character/modifiers // 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(); g_mario->destroy();
} }
void updateToolSelection( int prev_index ) { void updateToolSelection( int prev_index ) {
size_t prev = prev_index * 8; size_t prev = prev_index * 8;
size_t cur = g_current_tool_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++) { for ( size_t i = prev;
i < ( g_tools.size() < prev + 8 ? g_tools.size() : prev + 8 ); i++ ) {
g_tools[i]->setHidden( true ); g_tools[i]->setHidden( true );
} }
for(size_t i = cur; i < (g_tools.size() < cur + 8 ? g_tools.size() : cur + 8); i++) { for ( size_t i = cur;
i < ( g_tools.size() < cur + 8 ? g_tools.size() : cur + 8 ); i++ ) {
g_tools[i]->setHidden( false ); g_tools[i]->setHidden( false );
} }
} }
@ -150,17 +159,21 @@ void handleKeyUp( SDL_Keycode key, SDLPP::Scene &scene ) {
void getMousePositionFlags( SDLPP::Scene &scene ) { void getMousePositionFlags( SDLPP::Scene &scene ) {
auto mouse = scene.getObjects( { EDITOR_MOUSE_ID } )[0]; auto mouse = scene.getObjects( { EDITOR_MOUSE_ID } )[0];
// move mouse colider to mouse position // 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; MouseVisitor visitor;
scene.visitCollisions( *mouse, visitor ); scene.visitCollisions( *mouse, visitor );
std::get< MouseInfo::CUR_FLAGS >( g_mouse_info ) = visitor.getFlags(); std::get< MouseInfo::CUR_FLAGS >( g_mouse_info ) = visitor.getFlags();
std::get<MouseInfo::EDIT_BOX>(g_mouse_info) = visitor.getEditBoxIndexes(); std::get< MouseInfo::EDIT_BOX >( g_mouse_info ) =
std::get<MouseInfo::TOOL_BOX>(g_mouse_info) = visitor.getToolBoxIndexes(); 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 we found an edit box, move tool icon to that box
if ( visitor.foundEditBox() ) { if ( visitor.foundEditBox() ) {
const auto &box = std::get< MouseInfo::EDIT_BOX >( g_mouse_info ); 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); g_current_tool->setPos( BLOCK_SIZE + box.getX() * BLOCK_SIZE,
4 * BLOCK_SIZE + box.getY() * BLOCK_SIZE );
} }
} }
@ -183,14 +196,17 @@ void mouseUpAction(uint64_t flags, SDLPP::Scene &scene) {
g_current_tool_index -= 1; 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; g_current_tool_index += 1;
updateToolSelection( g_current_tool_index - 1 ); updateToolSelection( g_current_tool_index - 1 );
} }
} }
SDLPP::Vec2D< int > getSelectedObjectPosition() { 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() }; 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() { mapObjectType &getSelectedObject() {
@ -238,7 +254,10 @@ void placeTool(SDLPP::Scene &scene) {
std::get< MapObject::TERRAIN_TYPE >( obj ) = LandType::OVERWORLD; std::get< MapObject::TERRAIN_TYPE >( obj ) = LandType::OVERWORLD;
std::get< MapObject::TERRAIN_ID >( obj ) = g_current_tool->getId(); std::get< MapObject::TERRAIN_ID >( obj ) = g_current_tool->getId();
// TODO why 1 +? // 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 = 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 ); new_obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID );
break; break;
case VisitorType::Modifier: case VisitorType::Modifier:
@ -248,7 +267,10 @@ void placeTool(SDLPP::Scene &scene) {
std::get< MapObject::CHARACTER_ID >( obj ) = MARIO_ID; std::get< MapObject::CHARACTER_ID >( obj ) = MARIO_ID;
std::get< MapObject::MODIFIER_TYPE >( obj ) = 0; std::get< MapObject::MODIFIER_TYPE >( obj ) = 0;
std::get< MapObject::MODIFIER_DATA >( 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()); 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 // remove mario if exists
removeMario(); removeMario();
g_mario = new_obj; g_mario = new_obj;
@ -283,14 +305,19 @@ void pollEvents( SDLPP::Scene &scene ) {
getMousePositionFlags( scene ); getMousePositionFlags( scene );
break; break;
case SDL_MOUSEBUTTONUP: case SDL_MOUSEBUTTONUP:
if(std::get<MouseInfo::CUR_FLAGS>(g_mouse_info) == std::get<MouseInfo::PREV_FLAGS>(g_mouse_info)) { if ( std::get< MouseInfo::CUR_FLAGS >( g_mouse_info ) ==
mouseUpAction(std::get<MouseInfo::CUR_FLAGS>(g_mouse_info), scene); std::get< MouseInfo::PREV_FLAGS >( g_mouse_info ) ) {
mouseUpAction( std::get< MouseInfo::CUR_FLAGS >( g_mouse_info ),
scene );
} }
if(std::get<MouseInfo::EDIT_BOX>(g_mouse_info).getX() != -1) { if ( std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX() !=
-1 ) {
placeTool( scene ); placeTool( scene );
} }
if(std::get<MouseInfo::TOOL_BOX>(g_mouse_info).getX() != -1) { if ( std::get< MouseInfo::TOOL_BOX >( g_mouse_info ).getX() !=
auto &tool_box = std::get<MouseInfo::TOOL_BOX>(g_mouse_info); -1 ) {
auto &tool_box =
std::get< MouseInfo::TOOL_BOX >( g_mouse_info );
size_t index = tool_box.getY() * 4 + tool_box.getX(); 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; g_current_block = g_current_tool_index * 8 + index;
@ -300,7 +327,8 @@ void pollEvents( SDLPP::Scene &scene ) {
break; break;
case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONDOWN:
// store current mouse flags in previous mouse flags // store current mouse flags in previous mouse flags
std::get<MouseInfo::PREV_FLAGS>(g_mouse_info) = std::get<MouseInfo::CUR_FLAGS>(g_mouse_info); std::get< MouseInfo::PREV_FLAGS >( g_mouse_info ) =
std::get< MouseInfo::CUR_FLAGS >( g_mouse_info );
break; break;
default: default:
break; break;
@ -351,7 +379,8 @@ int main() {
// grid // grid
for ( int i = 1; i < 20; i++ ) { for ( int i = 1; i < 20; i++ ) {
auto line_vertical = std::make_shared< SDLPP::LineRenderer >( 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->setPermanent();
line_vertical->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); line_vertical->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
scene->addObject( line_vertical ); scene->addObject( line_vertical );
@ -360,13 +389,15 @@ int main() {
BLOCK_SIZE, ( i + 1 ) * BLOCK_SIZE, 19 * BLOCK_SIZE, BLOCK_SIZE, ( i + 1 ) * BLOCK_SIZE, 19 * BLOCK_SIZE,
( i + 1 ) * BLOCK_SIZE, g_renderer, "#282828" ); ( i + 1 ) * BLOCK_SIZE, g_renderer, "#282828" );
line_horizontal->setPermanent(); line_horizontal->setPermanent();
line_horizontal->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); line_horizontal->setAlignment( SDLPP::OBJ_CENTER,
SDLPP::OBJ_CENTER );
scene->addObject( line_horizontal ); scene->addObject( line_horizontal );
} }
} }
// white rectangles // white rectangles
auto rectangle1 = std::make_shared< SDLPP::RectangleRender >( auto rectangle1 = std::make_shared< SDLPP::RectangleRender >(
0, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE, g_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->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
rectangle1->setId( EDITOR_LEFT_MAP_ID ); rectangle1->setId( EDITOR_LEFT_MAP_ID );
rectangle1->setPermanent(); rectangle1->setPermanent();
@ -374,7 +405,8 @@ int main() {
scene->addObject( rectangle1 ); scene->addObject( rectangle1 );
// white rectangles // white rectangles
auto rectangle2 = std::make_shared< SDLPP::RectangleRender >( auto rectangle2 = std::make_shared< SDLPP::RectangleRender >(
19*BLOCK_SIZE, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE, g_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->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
rectangle2->setId( EDITOR_RIGHT_MAP_ID ); rectangle2->setId( EDITOR_RIGHT_MAP_ID );
rectangle2->setPermanent(); rectangle2->setPermanent();
@ -385,13 +417,15 @@ int main() {
auto font_config = std::make_shared< SDLPP::FontConfiguration >( auto font_config = std::make_shared< SDLPP::FontConfiguration >(
font, "#000000", "#282828", 0.05 ); font, "#000000", "#282828", 0.05 );
auto left = std::make_shared< SDLPP::TextRenderer >( auto left = std::make_shared< SDLPP::TextRenderer >(
0, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, "<", font_config); 0, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, "<",
font_config );
left->setId( 0 ); left->setId( 0 );
left->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); left->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
left->setPermanent(); left->setPermanent();
scene->addObject( left ); scene->addObject( left );
auto right = std::make_shared< SDLPP::TextRenderer >( auto right = std::make_shared< SDLPP::TextRenderer >(
19*BLOCK_SIZE, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, ">", font_config); 19 * BLOCK_SIZE, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer,
">", font_config );
right->setId( 0 ); right->setId( 0 );
right->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); right->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
right->setPermanent(); right->setPermanent();
@ -403,15 +437,14 @@ int main() {
} }
} }
auto mouse = auto mouse = std::make_shared< SDLPP::RectangleRender >( 0.01, 0.01, 0, 0,
std::make_shared< SDLPP::RectangleRender >( 0.01, 0.01, 0, 0, g_renderer ); g_renderer );
mouse->setMinWidth( 1 ); mouse->setMinWidth( 1 );
mouse->setMinHeight( 1 ); mouse->setMinHeight( 1 );
mouse->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); mouse->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
mouse->setId( EDITOR_MOUSE_ID ); mouse->setId( EDITOR_MOUSE_ID );
mouse->setColiderColor( "#00FF00" ); mouse->setColiderColor( "#00FF00" );
mouse->addCollision( mouse->addCollision( SDLPP::RectColider( { 0, 0 }, { 1, 1 } ) );
SDLPP::RectColider( { 0, 0 }, { 1, 1 } ) );
scene->addObject( mouse ); scene->addObject( mouse );
g_current_max_index = g_objects.size() - 18; g_current_max_index = g_objects.size() - 18;
@ -422,15 +455,19 @@ int main() {
auto tool_box2 = std::make_shared< ToolBox >( i, 1, g_renderer ); auto tool_box2 = std::make_shared< ToolBox >( i, 1, g_renderer );
scene->addObject( tool_box1 ); scene->addObject( tool_box1 );
scene->addObject( tool_box2 ); 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_box1->getPos().getX() <<
// std::cout << "TOOL BOX POS: " << tool_box2->getPos().getX() << ", " << tool_box2->getPos().getY() << std::endl; // ", " << 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; int tool_index = 0;
for ( auto &block : possibleBlocks ) { for ( auto &block : possibleBlocks ) {
if ( block == MARIO_ID ) { if ( block == MARIO_ID ) {
g_tools.push_back(createMario(LandType::OVERWORLD, g_renderer, 0, 0)); g_tools.push_back(
createMario( LandType::OVERWORLD, g_renderer, 0, 0 ) );
} else { } 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(); g_tools.back()->setPermanent();
@ -438,28 +475,35 @@ int main() {
auto y = tool_index / 4; auto y = tool_index / 4;
// TODO add 14 and 1 as constants somewhere // TODO add 14 and 1 as constants somewhere
// TODO investigate when not permanent requires `-1` on x position // 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); g_tools.back()->setPos( 14 * BLOCK_SIZE + x * BLOCK_SIZE,
// std::cout << "TOOL POS: " << tools.back()->getPos().getX() << ", " << tools.back()->getPos().getY() << std::endl; BLOCK_SIZE + y * BLOCK_SIZE );
// std::cout << "TOOL POS: " << tools.back()->getPos().getX() <<
// ", " << tools.back()->getPos().getY() << std::endl;
scene->addObject( g_tools.back() ); scene->addObject( g_tools.back() );
tool_index = ( tool_index + 1 ) % 8; tool_index = ( tool_index + 1 ) % 8;
} }
for ( int i = 0; i < 5; i++ ) { for ( int i = 0; i < 5; i++ ) {
auto line = std::make_shared< SDLPP::LineRenderer >( 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"); 14 * BLOCK_SIZE + i * BLOCK_SIZE, BLOCK_SIZE,
14 * BLOCK_SIZE + i * BLOCK_SIZE, 3 * BLOCK_SIZE, g_renderer,
"#282828" );
line->setPermanent(); line->setPermanent();
line->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); line->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
scene->addObject( line ); scene->addObject( line );
} }
for ( int i = 0; i < 3; i++ ) { for ( int i = 0; i < 3; i++ ) {
auto line = std::make_shared< SDLPP::LineRenderer >( 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"); 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->setPermanent();
line->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); line->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
scene->addObject( line ); scene->addObject( line );
} }
auto tool_rect1 = std::make_shared< SDLPP::RectangleRender >( auto tool_rect1 = std::make_shared< SDLPP::RectangleRender >(
13*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, g_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->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
tool_rect1->setId( EDITOR_LEFT_TOOL_ID ); tool_rect1->setId( EDITOR_LEFT_TOOL_ID );
tool_rect1->setPermanent(); tool_rect1->setPermanent();
@ -467,20 +511,23 @@ int main() {
scene->addObject( tool_rect1 ); scene->addObject( tool_rect1 );
// white rectangles // white rectangles
auto tool_rect2 = std::make_shared< SDLPP::RectangleRender >( auto tool_rect2 = std::make_shared< SDLPP::RectangleRender >(
18*BLOCK_SIZE, 1 * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, g_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->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
tool_rect2->setId( EDITOR_RIGHT_TOOL_ID ); tool_rect2->setId( EDITOR_RIGHT_TOOL_ID );
tool_rect2->setPermanent(); tool_rect2->setPermanent();
tool_rect2->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) ); tool_rect2->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) );
scene->addObject( tool_rect2 ); scene->addObject( tool_rect2 );
auto left_tool = std::make_shared< SDLPP::TextRenderer >( auto left_tool = std::make_shared< SDLPP::TextRenderer >(
13*BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, "<", font_config); 13 * BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer,
"<", font_config );
left_tool->setId( 0 ); left_tool->setId( 0 );
left_tool->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); left_tool->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
left_tool->setPermanent(); left_tool->setPermanent();
scene->addObject( left_tool ); scene->addObject( left_tool );
auto right_tool = std::make_shared< SDLPP::TextRenderer >( auto right_tool = std::make_shared< SDLPP::TextRenderer >(
18*BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, ">", font_config); 18 * BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer,
">", font_config );
right_tool->setId( 0 ); right_tool->setId( 0 );
right_tool->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); right_tool->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
right_tool->setPermanent(); right_tool->setPermanent();
@ -492,7 +539,9 @@ int main() {
g_placeholder_mario = std::make_shared< SDLPP::Texture >( g_placeholder_mario = std::make_shared< SDLPP::Texture >(
g_renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); g_renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY );
g_placeholder_mario->setAlpha( 100 ); g_placeholder_mario->setAlpha( 100 );
g_current_tool = createTerrainBlock(possibleBlocks[g_current_block], LandType::OVERWORLD, g_renderer, g_placeholder_texture, false); 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 ) ); g_current_tool->addCollision( SDLPP::RectColider( 0.1, 0.1, 0.8, 0.8 ) );
dynamic_cast< MarioBlock & >( *g_current_tool ).setTool(); dynamic_cast< MarioBlock & >( *g_current_tool ).setTool();
scene->addObject( g_current_tool ); scene->addObject( g_current_tool );

6
mario/editor_visitor.cpp
View File

@ -62,12 +62,14 @@ void ToolVisitor::visit( const SDLPP::RenderObject &obj ) {
switch ( id ) { switch ( id ) {
case EDITOR_TERRAIN_ID: case EDITOR_TERRAIN_ID:
remove_block = true; remove_block = true;
if(obj.getId() == source_id && getVisitorType() == VisitorType::Terrain) { if ( obj.getId() == source_id &&
getVisitorType() == VisitorType::Terrain ) {
add_block = false; add_block = false;
} }
case EDITOR_CHARACTER_ID: case EDITOR_CHARACTER_ID:
remove_block = true; remove_block = true;
if(obj.getId() == source_id && getVisitorType() == VisitorType::Modifier) { if ( obj.getId() == source_id &&
getVisitorType() == VisitorType::Modifier ) {
add_block = false; add_block = false;
} }
default: default:

4
mario/editor_visitor.hpp
View File

@ -17,7 +17,9 @@ public:
MouseVisitor() {} MouseVisitor() {}
virtual void visit( const SDLPP::RenderObject &obj ) override; virtual void visit( const SDLPP::RenderObject &obj ) override;
virtual void setFromId( uint64_t /*UNUSED*/ ) 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() { uint64_t getFlags() {
return select_flags; return select_flags;
} }

57
mario/maploader.cpp
View File

@ -7,7 +7,10 @@
#include "objectids.hpp" #include "objectids.hpp"
// TODO move to one function // TODO move to one function
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,
std::shared_ptr< SDLPP::RectangleRender > mario,
const std::string &file,
std::shared_ptr< SDLPP::Renderer > &renderer ) {
std::ifstream map_file; 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; uint16_t cols;
@ -16,12 +19,15 @@ void loadMap(std::shared_ptr<SDLPP::Scene> &scene, std::shared_ptr<SDLPP::Rectan
for ( int j = 0; j < 16; j++ ) { for ( int j = 0; j < 16; j++ ) {
uint16_t input_number; uint16_t input_number;
uint8_t additional_data = 0; uint8_t additional_data = 0;
uint8_t character_type = 0, character = 0, modifier_type = 0, modifier_data = 0; uint8_t character_type = 0, character = 0, modifier_type = 0,
map_file.read((char *)&input_number, sizeof(uint16_t)/sizeof(char)); modifier_data = 0;
map_file.read( ( char * )&input_number,
sizeof( uint16_t ) / sizeof( char ) );
uint8_t type = ( input_number & 0xF000 ) >> 12; uint8_t type = ( input_number & 0xF000 ) >> 12;
uint16_t id = ( input_number & 0x0FFF ) | BLOCK_PREFIX; uint16_t id = ( input_number & 0x0FFF ) | BLOCK_PREFIX;
if ( type & 0x8 ) { if ( type & 0x8 ) {
map_file.read((char *)&additional_data, sizeof(uint8_t)/sizeof(char)); map_file.read( ( char * )&additional_data,
sizeof( uint8_t ) / sizeof( char ) );
type &= ~0x8; type &= ~0x8;
if ( additional_data & 0x80 ) { if ( additional_data & 0x80 ) {
// modifier // modifier
@ -39,12 +45,15 @@ void loadMap(std::shared_ptr<SDLPP::Scene> &scene, std::shared_ptr<SDLPP::Rectan
collision = true; collision = true;
} }
// TODO add modifiers to createTerrainBlock // TODO add modifiers to createTerrainBlock
auto obj = createTerrainBlock(id, static_cast<LandType::Value>(type), renderer, i, j, collision); auto obj =
createTerrainBlock( id, static_cast< LandType::Value >( type ),
renderer, i, j, collision );
if ( obj != nullptr ) if ( obj != nullptr )
scene->addObject( obj ); scene->addObject( obj );
if ( character ) { if ( character ) {
if ( character == MARIO_ID ) { if ( character == MARIO_ID ) {
mario->setPos(i * BLOCK_SIZE, 1 - (16-j) * BLOCK_SIZE); mario->setPos( i * BLOCK_SIZE,
1 - ( 16 - j ) * BLOCK_SIZE );
} }
} }
} }
@ -53,7 +62,9 @@ void loadMap(std::shared_ptr<SDLPP::Scene> &scene, std::shared_ptr<SDLPP::Rectan
} }
// editor loader // editor loader
void loadMap(std::shared_ptr<SDLPP::Scene> &scene, const std::string &file, std::shared_ptr<SDLPP::Renderer> &renderer, std::vector<mapColumnType> &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; 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; uint16_t cols;
@ -64,12 +75,15 @@ void loadMap(std::shared_ptr<SDLPP::Scene> &scene, const std::string &file, std:
for ( int j = 0; j < 16; j++ ) { for ( int j = 0; j < 16; j++ ) {
uint16_t input_number; uint16_t input_number;
uint8_t additional_data = 0; uint8_t additional_data = 0;
uint8_t character_type = 0, character = 0, modifier_type = 0, modifier_data = 0; uint8_t character_type = 0, character = 0, modifier_type = 0,
map_file.read((char *)&input_number, sizeof(uint16_t)/sizeof(char)); modifier_data = 0;
map_file.read( ( char * )&input_number,
sizeof( uint16_t ) / sizeof( char ) );
uint8_t type = ( input_number & 0xF000 ) >> 12; uint8_t type = ( input_number & 0xF000 ) >> 12;
uint16_t id = ( input_number & 0x0FFF ) | BLOCK_PREFIX; uint16_t id = ( input_number & 0x0FFF ) | BLOCK_PREFIX;
if ( type & 0x8 ) { if ( type & 0x8 ) {
map_file.read((char *)&additional_data, sizeof(uint8_t)/sizeof(char)); map_file.read( ( char * )&additional_data,
sizeof( uint8_t ) / sizeof( char ) );
type &= ~0x8; type &= ~0x8;
if ( additional_data & 0x80 ) { if ( additional_data & 0x80 ) {
// modifier // modifier
@ -82,14 +96,19 @@ void loadMap(std::shared_ptr<SDLPP::Scene> &scene, const std::string &file, std:
character = additional_data & 0x0F; 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 // TODO add modifiers to createTerrainBlock
auto obj = createTerrainBlock(id, static_cast<LandType::Value>(type), renderer, i, j, true); auto obj =
createTerrainBlock( id, static_cast< LandType::Value >( type ),
renderer, i, j, true );
obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID ); obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID );
scene->addObject( obj ); scene->addObject( obj );
if ( character ) { if ( character ) {
if ( character == MARIO_ID ) { if ( character == MARIO_ID ) {
scene->addObject(createMario(static_cast<LandType::Value>(character_type), renderer, i, j)); scene->addObject( createMario(
static_cast< LandType::Value >( character_type ),
renderer, i, j ) );
} }
} }
} }
@ -99,7 +118,8 @@ void loadMap(std::shared_ptr<SDLPP::Scene> &scene, const std::string &file, std:
} }
} }
// tuple - world object type, object, world character type, character, modifier type, modifier data // tuple - world object type, object, world character type, character, modifier
// type, modifier data
void saveMap( const std::string &file, std::vector< mapColumnType > &objects ) { void saveMap( const std::string &file, std::vector< mapColumnType > &objects ) {
std::ofstream output_file; std::ofstream output_file;
output_file.open( file, std::ios::out | std::ios::binary ); output_file.open( file, std::ios::out | std::ios::binary );
@ -111,11 +131,13 @@ void saveMap(const std::string &file, std::vector<mapColumnType> &objects) {
uint16_t wide_type = std::get< 0 >( obj ); uint16_t wide_type = std::get< 0 >( obj );
wide_type = wide_type << 12; wide_type = wide_type << 12;
uint16_t write_num = ( 0x0FFF & std::get< 1 >( obj ) ) | wide_type; 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) // 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 ) ) { if ( std::get< 3 >( obj ) || std::get< 4 >( obj ) ) {
write_num |= 0x8000; 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; uint8_t additional_data = 0;
if ( std::get< 3 >( obj ) ) { if ( std::get< 3 >( obj ) ) {
additional_data |= std::get< 2 >( obj ) << 4; additional_data |= std::get< 2 >( obj ) << 4;
@ -126,7 +148,8 @@ void saveMap(const std::string &file, std::vector<mapColumnType> &objects) {
additional_data |= std::get< 5 >( obj ); additional_data |= std::get< 5 >( obj );
} }
if ( additional_data ) { if ( additional_data ) {
output_file.write((char*)&additional_data, sizeof(uint8_t)/sizeof(char)); output_file.write( ( char * )&additional_data,
sizeof( uint8_t ) / sizeof( char ) );
} }
} }
} }

12
mario/maploader.hpp
View File

@ -15,11 +15,17 @@ struct MapObject {
}; };
}; };
typedef std::tuple<uint8_t, uint16_t, uint8_t, uint8_t, uint8_t, uint8_t> mapObjectType; typedef std::tuple< uint8_t, uint16_t, uint8_t, uint8_t, uint8_t, uint8_t >
mapObjectType;
typedef std::array< mapObjectType, 16 > mapColumnType; typedef std::array< mapObjectType, 16 > mapColumnType;
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,
void loadMap(std::shared_ptr<SDLPP::Scene> &scene, const std::string &file, std::shared_ptr<SDLPP::Renderer> &renderer, std::vector<mapColumnType> &objects); 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 ); void saveMap( const std::string &file, std::vector< mapColumnType > &objects );
#endif #endif

1
mario/objectids.hpp
View File

@ -64,7 +64,6 @@
// modifiers // modifiers
// character IDs // character IDs
#define MARIO_ID 0x0F #define MARIO_ID 0x0F