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 <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 ) {
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 );
@ -22,7 +29,8 @@ void MarioBlock::setTerrain(bool terrain) {
_terrain = terrain;
}
const std::vector< uint64_t > possibleBlocks = { FLOOR_ID,
const std::vector< uint64_t > possibleBlocks = {
FLOOR_ID,
STEP_ID,
HILL_TOP_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 = {
{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},
{ 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 },
@ -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_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},
{ 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_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}
{ CANNON_ID, &CANNON_SRC },
{ MARIO_ID, &MARIO_STANDING_SRC }
};
std::shared_ptr< SDLPP::RectangleRender >
@ -162,32 +191,46 @@ SDL_Rect getSourceRectByID( uint64_t id, LandType::Value type ) {
}
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,
getSourceRectByID( block_id, type ), block_id,
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,
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<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
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 );
return mario;
}

37
mario/blocks.hpp
View File

@ -6,10 +6,12 @@
class MarioBlock : public SDLPP::RectangleRender {
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 setTool( bool tool = true );
void setTerrain( bool terrain = true );
private:
bool _tool = false;
bool _terrain = true;
@ -18,12 +20,7 @@ private:
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,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> 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 );
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 );

137
mario/editor.cpp
View File

@ -36,8 +36,10 @@ bool g_update_size = false;
std::vector< mapColumnType > g_objects = {};
std::mutex g_destruction_mutex;
// 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;
// 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;
@ -71,9 +73,12 @@ void updateTool() {
case BlockRole::CHARACTER:
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->getCollisions()[0]->setId(possibleBlocks[g_current_block]);
g_current_tool->getCollisions()[0]->setId(
possibleBlocks[g_current_block] );
}
void removeMario() {
@ -81,17 +86,21 @@ void removeMario() {
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 ) {
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++) {
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++) {
for ( size_t i = cur;
i < ( g_tools.size() < cur + 8 ? g_tools.size() : cur + 8 ); i++ ) {
g_tools[i]->setHidden( false );
}
}
@ -150,17 +159,21 @@ void handleKeyUp( SDL_Keycode key, SDLPP::Scene &scene ) {
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< 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();
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< 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;
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 );
}
}
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() {
@ -238,7 +254,10 @@ void placeTool(SDLPP::Scene &scene) {
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 = 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:
@ -248,7 +267,10 @@ void placeTool(SDLPP::Scene &scene) {
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());
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;
@ -283,14 +305,19 @@ void pollEvents( SDLPP::Scene &scene ) {
getMousePositionFlags( scene );
break;
case SDL_MOUSEBUTTONUP:
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< 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<MouseInfo::EDIT_BOX>(g_mouse_info).getX() != -1) {
if ( std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX() !=
-1 ) {
placeTool( scene );
}
if(std::get<MouseInfo::TOOL_BOX>(g_mouse_info).getX() != -1) {
auto &tool_box = std::get<MouseInfo::TOOL_BOX>(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() ) {
g_current_block = g_current_tool_index * 8 + index;
@ -300,7 +327,8 @@ void pollEvents( SDLPP::Scene &scene ) {
break;
case SDL_MOUSEBUTTONDOWN:
// 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;
default:
break;
@ -351,7 +379,8 @@ 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 );
@ -360,13 +389,15 @@ int main() {
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 );
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);
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();
@ -374,7 +405,8 @@ int main() {
scene->addObject( rectangle1 );
// white rectangles
auto rectangle2 = std::make_shared< SDLPP::RectangleRender >(
19*BLOCK_SIZE, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE, 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->setId( EDITOR_RIGHT_MAP_ID );
rectangle2->setPermanent();
@ -385,13 +417,15 @@ int main() {
auto font_config = std::make_shared< SDLPP::FontConfiguration >(
font, "#000000", "#282828", 0.05 );
auto left = std::make_shared< SDLPP::TextRenderer >(
0, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, "<", font_config);
0, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, "<",
font_config );
left->setId( 0 );
left->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
left->setPermanent();
scene->addObject( left );
auto right = std::make_shared< SDLPP::TextRenderer >(
19*BLOCK_SIZE, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, ">", font_config);
19 * BLOCK_SIZE, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer,
">", font_config );
right->setId( 0 );
right->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
right->setPermanent();
@ -403,15 +437,14 @@ int main() {
}
}
auto mouse =
std::make_shared< SDLPP::RectangleRender >( 0.01, 0.01, 0, 0, g_renderer );
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->addCollision( SDLPP::RectColider( { 0, 0 }, { 1, 1 } ) );
scene->addObject( mouse );
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 );
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;
// 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));
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()->setPermanent();
@ -438,28 +475,35 @@ int main() {
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;
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< 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->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
scene->addObject( line );
}
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");
14 * BLOCK_SIZE, BLOCK_SIZE + i * BLOCK_SIZE,
14 * BLOCK_SIZE + 4 * BLOCK_SIZE, BLOCK_SIZE + i * BLOCK_SIZE,
g_renderer, "#282828" );
line->setPermanent();
line->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
scene->addObject( line );
}
auto tool_rect1 = std::make_shared< SDLPP::RectangleRender >(
13*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, 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->setId( EDITOR_LEFT_TOOL_ID );
tool_rect1->setPermanent();
@ -467,20 +511,23 @@ int main() {
scene->addObject( tool_rect1 );
// white rectangles
auto tool_rect2 = std::make_shared< SDLPP::RectangleRender >(
18*BLOCK_SIZE, 1 * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, 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->setId( EDITOR_RIGHT_TOOL_ID );
tool_rect2->setPermanent();
tool_rect2->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) );
scene->addObject( tool_rect2 );
auto left_tool = std::make_shared< SDLPP::TextRenderer >(
13*BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, 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->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
left_tool->setPermanent();
scene->addObject( left_tool );
auto right_tool = std::make_shared< SDLPP::TextRenderer >(
18*BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, 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->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
right_tool->setPermanent();
@ -492,7 +539,9 @@ int main() {
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 = 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 );

6
mario/editor_visitor.cpp
View File

@ -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:

4
mario/editor_visitor.hpp
View File

@ -17,7 +17,9 @@ 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;
}

57
mario/maploader.cpp
View File

@ -7,7 +7,10 @@
#include "objectids.hpp"
// 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;
map_file.open( file, std::ios::in | std::ios::binary );
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++ ) {
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 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));
map_file.read( ( char * )&additional_data,
sizeof( uint8_t ) / sizeof( char ) );
type &= ~0x8;
if ( additional_data & 0x80 ) {
// modifier
@ -39,12 +45,15 @@ void loadMap(std::shared_ptr<SDLPP::Scene> &scene, std::shared_ptr<SDLPP::Rectan
collision = true;
}
// 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 )
scene->addObject( obj );
if ( character ) {
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
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;
map_file.open( file, std::ios::in | std::ios::binary );
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++ ) {
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 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));
map_file.read( ( char * )&additional_data,
sizeof( uint8_t ) / sizeof( char ) );
type &= ~0x8;
if ( additional_data & 0x80 ) {
// modifier
@ -82,14 +96,19 @@ void loadMap(std::shared_ptr<SDLPP::Scene> &scene, const std::string &file, std:
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<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 );
scene->addObject( obj );
if ( character ) {
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 ) {
std::ofstream output_file;
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 );
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)
// 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;
@ -126,7 +148,8 @@ void saveMap(const std::string &file, std::vector<mapColumnType> &objects) {
additional_data |= std::get< 5 >( obj );
}
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;
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 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

1
mario/objectids.hpp
View File

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