diff --git a/mario/Makefile b/mario/Makefile index a4ed73c..0e0af6d 100644 --- a/mario/Makefile +++ b/mario/Makefile @@ -18,7 +18,7 @@ endif COMMON_OBJECTS = blocks.${OBJEXT} global_vars.${OBJEXT} sprites.${OBJEXT} maploader.${OBJEXT} MARIO_OBJECTS = mario.${OBJEXT} mario_visitor.${OBJEXT} ${COMMON_OBJECTS} -EDITOR_OBJECTS = editor.${OBJEXT} ${COMMON_OBJECTS} +EDITOR_OBJECTS = editor.${OBJEXT} edit_box.${OBJEXT} editor_visitor.${OBJEXT} ${COMMON_OBJECTS} ifeq ($(UNAME_S),Linux) MARIO_OBJECTS += libsdlpp.so @@ -61,6 +61,10 @@ mario_visitor.${OBJEXT}: mario_visitor.cpp ../sdlpp/sdlpp.hpp mario_visitor.hpp $(CXX) $(CXXFLAGS) -c ${OUTPUTFLAG}$@ $< editor.${OBJEXT}: editor.cpp ../sdlpp/sdlpp.hpp sprites.hpp $(CXX) $(CXXFLAGS) -c ${OUTPUTFLAG}$@ $< +edit_box.${OBJEXT}: edit_box.cpp ../sdlpp/sdlpp.hpp sprites.hpp edit_box.hpp + $(CXX) $(CXXFLAGS) -c ${OUTPUTFLAG}$@ $< +editor_visitor.${OBJEXT}: editor_visitor.cpp ../sdlpp/sdlpp.hpp sprites.hpp editor_visitor.hpp + $(CXX) $(CXXFLAGS) -c ${OUTPUTFLAG}$@ $< libsdlpp.so: ../sdlpp $(MAKE) clean -C ../sdlpp $(MAKE) -C ../sdlpp diff --git a/mario/blocks.cpp b/mario/blocks.cpp index f1d63d0..bced785 100644 --- a/mario/blocks.cpp +++ b/mario/blocks.cpp @@ -4,6 +4,17 @@ #include "sprites.hpp" #include +MarioBlock::MarioBlock(int x, int y, std::shared_ptr renderer, std::shared_ptr texture, SDL_Rect src) : RectangleRender( x * BLOCK_SIZE, 1 - (16-y) * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer, texture, src ) {} +void MarioBlock::visit( SDLPP::Visitor &visitor ) { + if(!_tool && visitor.getVisitorType() == TOOL_VISITOR_TYPE) { + destroy(); + } + visitor.visit(*this); +} +void MarioBlock::setTool(bool tool) { + _tool = tool; +} + const std::vector< uint64_t > possibleBlocks = { FLOOR_ID, HILL_INCLINE_ID, HILL_DECLINE_ID, @@ -33,11 +44,10 @@ const std::unordered_map block_mapping = { }; std::shared_ptr< SDLPP::RectangleRender > -createBlock( std::shared_ptr< SDLPP::Renderer > &renderer, double x, double y, +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< SDLPP::RectangleRender >( - x, y, BLOCK_SIZE, BLOCK_SIZE, renderer, texture, src ); + auto block = std::make_shared(x, y, renderer, texture, src); block->setId( id ); block->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); block->setStatic(); @@ -70,7 +80,7 @@ SDL_Rect getSourceRectByID( uint64_t id, BlockType type ) { } return ret_src; } -std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, double x, double y, std::shared_ptr texture, bool collision ) { +std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, int x, int y, std::shared_ptr texture, bool collision ) { return createBlock( renderer, x, y, texture, getSourceRectByID( block_id, type ), block_id, collision ); @@ -81,8 +91,8 @@ std::shared_ptr createTerrainBlock( uint64_t block_id, B std::shared_ptr< SDLPP::RectangleRender > createTerrainBlock( uint64_t block_id, BlockType type, - std::shared_ptr< SDLPP::Renderer > &renderer, double x, - double y, bool 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); } @@ -93,7 +103,7 @@ createTerrainBlock( uint64_t block_id, BlockType type, return createTerrainBlock(block_id, type, renderer, g_terrain_texture, collision); } -std::shared_ptr createMario( BlockType type, std::shared_ptr &renderer, double x, double y ) { +std::shared_ptr createMario( BlockType type, std::shared_ptr &renderer, int x, int y ) { //TODO add type additions return createBlock( renderer, x, y, g_mario_texture, MARIO_STANDING_SRC, MARIO_ID, true ); } diff --git a/mario/blocks.hpp b/mario/blocks.hpp index f2950d2..f363465 100644 --- a/mario/blocks.hpp +++ b/mario/blocks.hpp @@ -4,6 +4,15 @@ #include "../sdlpp/sdlpp_rectrenderer.hpp" #include +class MarioBlock : public SDLPP::RectangleRender { +public: + MarioBlock(int x, int y, std::shared_ptr renderer, std::shared_ptr texture, SDL_Rect src); + void visit( SDLPP::Visitor &visitor ) override; + void setTool(bool tool = true); +private: + bool _tool = false; +}; + extern const std::vector possibleBlocks; enum BlockType { @@ -14,9 +23,9 @@ enum BlockType { }; std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, bool collision = false ); -std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, double x, double y, bool collision = false ); +std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, int x, int y, bool collision = false ); std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, std::shared_ptr texture, bool collision = false ); -std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, double x, double y, std::shared_ptr texture, bool collision = false ); -std::shared_ptr createMario( BlockType type, std::shared_ptr &renderer, double x, double y ); +std::shared_ptr createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr &renderer, int x, int y, std::shared_ptr texture, bool collision = false ); +std::shared_ptr createMario( BlockType type, std::shared_ptr &renderer, int x, int y ); #endif diff --git a/mario/edit_box.cpp b/mario/edit_box.cpp new file mode 100644 index 0000000..4dd6679 --- /dev/null +++ b/mario/edit_box.cpp @@ -0,0 +1,19 @@ +#include "edit_box.hpp" + +EditBox::EditBox(int x, int y, std::shared_ptr renderer) : SDLPP::RectangleRender(BLOCK_SIZE + x*BLOCK_SIZE, 4*BLOCK_SIZE + y*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer) { + _x = x; + _y = y; + setId(EDITOR_EDIT_SQUARE); + setColiderColor("#FF00AA"); + setPermanent(); + setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); + addCollision(SDLPP::RectColider(0,0,1,1)); +} + +SDLPP::Vec2D EditBox::getIndexes() const { + return {_x, _y}; +} + +void EditBox::visit( SDLPP::Visitor &visitor ) { + visitor.visit( *this ); +} diff --git a/mario/edit_box.hpp b/mario/edit_box.hpp new file mode 100644 index 0000000..bbb78ce --- /dev/null +++ b/mario/edit_box.hpp @@ -0,0 +1,14 @@ +#include "../sdlpp/sdlpp.hpp" +#include "objectids.hpp" +#include "blocks.hpp" +#include "sprites.hpp" + +class EditBox : public SDLPP::RectangleRender { +public: + EditBox(int x, int y, std::shared_ptr renderer); + SDLPP::Vec2D getIndexes() const; + void visit( SDLPP::Visitor &visitor ) override; +private: + int _x; + int _y; +}; diff --git a/mario/editor.cpp b/mario/editor.cpp index e22fdbd..30369bb 100644 --- a/mario/editor.cpp +++ b/mario/editor.cpp @@ -10,47 +10,27 @@ #endif // UNIX #include +#include #include "global_vars.hpp" #include "objectids.hpp" #include "blocks.hpp" #include "maploader.hpp" #include "../sdlpp/sdlpp_mouse.hpp" - -#define EDIT_SQUARE 0xF001 -#define MOUSE_ID 0xF002 -#define LEFT_ID 0xF003 -#define RIGHT_ID 0xF004 +#include "edit_box.hpp" +#include "editor_visitor.hpp" std::shared_ptr< SDLPP::Renderer > renderer = nullptr; bool quit = false; -std::vector,16>> objects = {}; bool update_size = false; -bool selected_left = false; -bool selected_right = false; +std::vector,16>> objects = {}; +uint64_t current_selected_flags = 0; +uint64_t previous_selected_flags = 0; +std::mutex destruction_mutex; + int current_start_index = 0; int current_max_index = 0; -std::pair current_box = {0, 0}; -std::pair backup_box = {0, 0}; -std::shared_ptr placeholderGround = nullptr; - -class EditBox : public SDLPP::RectangleRender { -public: - EditBox(int x, int y, std::shared_ptr renderer) : SDLPP::RectangleRender(BLOCK_SIZE + x*BLOCK_SIZE, 4*BLOCK_SIZE + y*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer) { - _x = x; - _y = y; - setId(EDIT_SQUARE); - setColiderColor("#FF00AA"); - setPermanent(); - setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); - addCollision(SDLPP::RectColider(0,0,1,1)); - } - std::pair getIndexes() { - return {_x, _y}; - } -private: - int _x; - int _y; -}; +SDLPP::Vec2D current_box = {0, 0}; +std::shared_ptr current_tool = nullptr; void handleKeyDown( SDL_Keycode key, SDLPP::Scene &scene ) { switch ( key ) { @@ -107,59 +87,48 @@ void pollEvents( SDLPP::Scene &scene ) { } break; case SDL_MOUSEMOTION: { - auto mouse = scene.getObjects({MOUSE_ID})[0]; + auto mouse = scene.getObjects({EDITOR_MOUSE_ID})[0]; mouse->setPos(SDLPP::Mouse::getMousePositionDouble(scene.getRenderer(), SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER)); - auto collisions = scene.getCollisions(*mouse); - selected_left = false; - selected_right = false; - current_box = {-1, -1}; - if(collisions.size() >= 2) { - for(auto &collision : collisions) { - if(collision.second->getId() == EDIT_SQUARE) { - current_box = dynamic_cast(*collision.second).getIndexes(); - placeholderGround->setPos(BLOCK_SIZE + current_box.first * BLOCK_SIZE, 4*BLOCK_SIZE + current_box.second * BLOCK_SIZE); - } else if (collision.second->getId() == LEFT_ID) { - selected_left = true; - } else if (collision.second->getId() == RIGHT_ID) { - selected_right = true; - } - } + MouseVisitor visitor; + scene.visitCollisions(*mouse, visitor); + current_selected_flags = visitor.getFlags(); + current_box = visitor.getEditBoxIndexes(); + if(visitor.foundEditBox()) { + current_tool->setPos(BLOCK_SIZE + current_box.getX() * BLOCK_SIZE, 4*BLOCK_SIZE + current_box.getY() * BLOCK_SIZE); } } break; case SDL_MOUSEBUTTONUP: - if(selected_left && current_start_index != 0) { + if(previous_selected_flags == current_selected_flags && MouseVisitor::moveMapLeft(current_selected_flags) && current_start_index != 0) { current_start_index -= 1; scene.moveEverything(BLOCK_SIZE, 0); } - if(selected_right && current_start_index != current_max_index) { + if(previous_selected_flags == current_selected_flags && MouseVisitor::moveMapRight(current_selected_flags) && current_start_index != current_max_index) { current_start_index += 1; scene.moveEverything(-BLOCK_SIZE,0); } - if(current_box == backup_box && current_box.first != -1) { - auto mouse = scene.getObjects({MOUSE_ID})[0]; - mouse->setPos(SDLPP::Mouse::getMousePositionDouble(scene.getRenderer(), SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER)); - auto collisions = scene.getCollisions(*mouse); - std::cout << "BOUT TO" << std::endl; - bool deleted = false; - for(auto &collision : collisions) { - if(collision.second->getId() == FLOOR_ID) { - std::cout << "DELETING" << std::endl; - collision.second->destroy(); - objects[current_start_index + current_box.first][current_box.second] = {OVERWORLD, 0, 0, 0, 0, 0}; - deleted = true; - break; - } + if(current_box.getX() != -1) { + std::lock_guard lock(destruction_mutex); + + ToolVisitor visitor; + visitor.setVisitorType(TOOL_VISITOR_TYPE); + scene.visitCollisions(*current_tool, visitor); + if(visitor.removeBlock()) { + // TODO check if modifier + objects[current_start_index + current_box.getX()][current_box.getY()] = {OVERWORLD, 0, 0, 0, 0, 0}; + } + if(visitor.addBlock()) { + // TODO check if modifier + objects[current_start_index + current_box.getX()][current_box.getY()] = {OVERWORLD, current_tool->getId(), 0, 0, 0, 0}; + auto obj = createTerrainBlock(current_tool->getId(), OVERWORLD, renderer, 1 + current_box.getX(), current_box.getY(), true); + obj->getCollisions()[0]->setId(EDITOR_TERRAIN_ID); + scene.addObject(obj); + scene.setZIndex(obj, 1); } - if(deleted) - break; - std::cout << "ADDING" << std::endl; - objects[current_start_index + current_box.first][current_box.second] = {OVERWORLD, FLOOR_ID, 0, 0, 0, 0}; - scene.addObject(createTerrainBlock(FLOOR_ID, OVERWORLD, renderer, BLOCK_SIZE + current_box.first * BLOCK_SIZE, 4*BLOCK_SIZE + current_box.second * BLOCK_SIZE, true)); } break; case SDL_MOUSEBUTTONDOWN: - backup_box = current_box; + previous_selected_flags = current_selected_flags; break; default: break; @@ -227,7 +196,7 @@ int main() { auto rectangle1 = std::make_shared< SDLPP::RectangleRender >( 0, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE, renderer, "#FFFFFF88", true); rectangle1->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); - rectangle1->setId(LEFT_ID); + rectangle1->setId(EDITOR_LEFT_MAP_ID); rectangle1->setPermanent(); rectangle1->addCollision(SDLPP::RectColider(0, 0, 1, 1)); scene->addObject(rectangle1); @@ -235,7 +204,7 @@ int main() { auto rectangle2 = std::make_shared< SDLPP::RectangleRender >( 19*BLOCK_SIZE, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE, renderer, "#FFFFFF88", true); rectangle2->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); - rectangle2->setId(RIGHT_ID); + rectangle2->setId(EDITOR_RIGHT_MAP_ID); rectangle2->setPermanent(); rectangle2->addCollision(SDLPP::RectColider(0, 0, 1, 1)); scene->addObject(rectangle2); @@ -245,13 +214,13 @@ int main() { font, "#000000", "#282828", 0.05 ); auto left = std::make_shared< SDLPP::TextRenderer >( 0, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer, "<", font_config); - left->setId(LEFT_ID); + left->setId(0); left->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); left->setPermanent(); scene->addObject(left); auto right = std::make_shared< SDLPP::TextRenderer >( 19*BLOCK_SIZE, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer, ">", font_config); - right->setId(RIGHT_ID); + right->setId(0); right->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); right->setPermanent(); scene->addObject(right); @@ -263,9 +232,11 @@ int main() { } auto mouse = - std::make_shared< SDLPP::RectangleRender >( 0.01, 0.01, 0.01, 0.01, renderer ); + std::make_shared< SDLPP::RectangleRender >( 0.01, 0.01, 0, 0, renderer ); + mouse->setMinWidth(1); + mouse->setMinHeight(1); mouse->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); - mouse->setId( MOUSE_ID ); + mouse->setId( EDITOR_MOUSE_ID ); mouse->setColiderColor("#00FF00"); mouse->addCollision( SDLPP::RectColider( { 0, 0 }, { 1, 1 } ) ); @@ -274,11 +245,12 @@ int main() { auto placeholder_texture = std::make_shared< SDLPP::Texture >( renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); - placeholderGround = createTerrainBlock(FLOOR_ID, OVERWORLD, renderer, placeholder_texture, true); - placeholderGround->setTextureAlpha(100); - placeholderGround->setId(0); - scene->addObject(placeholderGround); - scene->moveZTop(placeholderGround); + current_tool = createTerrainBlock(FLOOR_ID, OVERWORLD, renderer, placeholder_texture, false); + current_tool->addCollision(SDLPP::RectColider(0.1, 0.1, 0.8, 0.8)); + current_tool->setTextureAlpha(100); + dynamic_cast(*current_tool).setTool(); + scene->addObject(current_tool); + scene->moveZTop(current_tool); scene->moveEverything(BLOCK_SIZE, 0); FPSmanager gFPS; @@ -292,6 +264,7 @@ int main() { while ( !quit ) { SDL_PumpEvents(); SDL_framerateDelay( &gFPS ); + std::lock_guard lock(destruction_mutex); scene->renderScene(); renderer->presentRenderer(); frames++; diff --git a/mario/editor_visitor.cpp b/mario/editor_visitor.cpp new file mode 100644 index 0000000..c24bba7 --- /dev/null +++ b/mario/editor_visitor.cpp @@ -0,0 +1,56 @@ +#include "editor_visitor.hpp" +#include "../sdlpp/sdlpp_renderobject.hpp" +#include "objectids.hpp" +#include "edit_box.hpp" + +#define SELECTED_LEFT_MAP 0x00000001 +#define SELECTED_RIGHT_MAP 0x00000002 +#define SELECTED_LEFT_SELECT 0x00000004 +#define SELECTED_RIGHT_SELECT 0x00000004 +#define SELECTED_REMOVE_BLOCK 0x00000008 +#define SELECTED_REMOVE_MODIFIER 0x00000010 + +void MouseVisitor::visit( const SDLPP::RenderObject &obj ) { + auto id = obj.getId(); + switch ( id ) { + case EDITOR_LEFT_MAP_ID: + select_flags |= SELECTED_LEFT_MAP; + break; + case EDITOR_RIGHT_MAP_ID: + select_flags |= SELECTED_RIGHT_MAP; + break; + case EDITOR_EDIT_SQUARE: + edit_box = true; + edit_box_location = dynamic_cast(obj).getIndexes(); + break; + default: + break; + } +} + +bool MouseVisitor::moveMapLeft(uint64_t flags) { + return flags & SELECTED_LEFT_MAP; +} + +bool MouseVisitor::moveMapRight(uint64_t flags) { + return flags & SELECTED_RIGHT_MAP; +} + +void ToolVisitor::visit( const SDLPP::RenderObject &obj ) { + auto id = obj.getCollisions()[0]->getId(); + switch ( id ) { + case EDITOR_TERRAIN_ID: + remove_block = true; + if(obj.getId() == source_id) { + add_block = false; + } + default: + break; + } +} +bool ToolVisitor::addBlock() { + return add_block; +} +bool ToolVisitor::removeBlock() { + return remove_block; +} diff --git a/mario/editor_visitor.hpp b/mario/editor_visitor.hpp new file mode 100644 index 0000000..23801f1 --- /dev/null +++ b/mario/editor_visitor.hpp @@ -0,0 +1,66 @@ +#ifndef EDITOR_VISITOR_H +#define EDITOR_VISITOR_H + +#include "../sdlpp/sdlpp_visitor.hpp" +#include "../sdlpp/sdlpp_geometry.hpp" +#include + +class MouseVisitor : public SDLPP::Visitor { +public: + MouseVisitor() {} + virtual void visit( const SDLPP::RenderObject &obj ) override; + virtual void setFromId( uint64_t /*UNUSED*/ ) override {} + virtual uint64_t getFromId() override {return 0;} + uint64_t getFlags() { + return select_flags; + } + bool foundEditBox() { + return edit_box; + } + SDLPP::Vec2D getEditBoxIndexes() { + return edit_box_location; + } + virtual void setVisitorType( uint64_t type ) override { + _type = type; + } + virtual uint64_t getVisitorType() override { + return _type; + } + + static bool moveMapLeft(uint64_t flags); + static bool moveMapRight(uint64_t flags); + +private: + uint64_t select_flags = 0; + bool edit_box = false; + SDLPP::Vec2D edit_box_location = {-1, -1}; + uint64_t _type; +}; + +class ToolVisitor : public SDLPP::Visitor { +public: + ToolVisitor() {}; + virtual void visit( const SDLPP::RenderObject &obj ) override; + virtual void setFromId( uint64_t id ) override { + source_id = id; + } + virtual uint64_t getFromId() override { + return source_id; + } + virtual void setVisitorType( uint64_t type ) override { + _type = type; + } + virtual uint64_t getVisitorType() override { + return _type; + } + bool addBlock(); + bool removeBlock(); + +private: + bool remove_block = false; + bool add_block = true; + uint64_t source_id = 0; + uint64_t _type = 0; +}; + +#endif diff --git a/mario/maploader.cpp b/mario/maploader.cpp index 7d04446..0b85ffd 100644 --- a/mario/maploader.cpp +++ b/mario/maploader.cpp @@ -38,7 +38,7 @@ void loadMap(std::shared_ptr &scene, std::shared_ptr(type), renderer, i * BLOCK_SIZE, 1 - (16-j) * BLOCK_SIZE, collision); + auto obj = createTerrainBlock(id, static_cast(type), renderer, i, j, collision); if(obj != nullptr) scene->addObject(obj); if(character) { @@ -51,6 +51,7 @@ void loadMap(std::shared_ptr &scene, std::shared_ptrmoveZTop(mario); } +// editor loader void loadMap(std::shared_ptr &scene, const std::string &file, std::shared_ptr &renderer, std::vector,16>> &objects) { std::ifstream map_file; map_file.open(file, std::ios::in | std::ios::binary); @@ -81,17 +82,13 @@ void loadMap(std::shared_ptr &scene, const std::string &file, std: } } col[j] = {type, id, character_type, character, modifier_type, modifier_data}; - bool collision = false; - if(id == FLOOR_ID) { - collision = true; - } // TODO add modifiers to createTerrainBlock - auto obj = createTerrainBlock(id, static_cast(type), renderer, i * BLOCK_SIZE, 1 - (16-j) * BLOCK_SIZE, collision); - if(obj != nullptr) - scene->addObject(obj); + 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 * BLOCK_SIZE, 1 - (16-j) * BLOCK_SIZE)); + scene->addObject(createMario(static_cast(character_type), renderer, i, j)); } } } diff --git a/mario/mario_visitor.hpp b/mario/mario_visitor.hpp index 64086d8..78bab18 100644 --- a/mario/mario_visitor.hpp +++ b/mario/mario_visitor.hpp @@ -20,9 +20,18 @@ public: double newXPos() { return newX; } - virtual void fromId( uint64_t id ) override { + virtual void setFromId( uint64_t id ) override { from = id; } + virtual uint64_t getFromId() override { + return from; + } + virtual void setVisitorType( uint64_t type ) override { + _type = type; + } + virtual uint64_t getVisitorType() override { + return _type; + } bool canGoLeft() { return !left; } @@ -38,6 +47,7 @@ private: uint64_t from = -1; bool left = false; bool right = false; + uint64_t _type = 0; }; #endif diff --git a/mario/objectids.hpp b/mario/objectids.hpp index 70b620b..e010643 100644 --- a/mario/objectids.hpp +++ b/mario/objectids.hpp @@ -29,4 +29,14 @@ #define MARIO_LEFT_SIDE_DETECT 0x2002 #define MARIO_RIGHT_SIDE_DETECT 0x2003 +#define EDITOR_EDIT_SQUARE 0xF001 +#define EDITOR_MOUSE_ID 0xF002 +#define EDITOR_LEFT_MAP_ID 0xF003 +#define EDITOR_RIGHT_MAP_ID 0xF004 +#define EDITOR_TERRAIN_ID 0xF005 + +#define TOOL_VISITOR_TYPE 0xE001 +#define MOUSE_VISITOR_TYPE 0xE002 +#define MARIO_VISITOR_TYPE 0xE003 + #endif