zv0n/game
1
0
Fork 0
Code Issues Pull Requests Actions Packages 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
Download Patch File Download Diff File Expand all files Collapse all files
mario/editor.cpp
+277 -228
View File
@@ -33,85 +33,94 @@ struct MouseInfo {
std::shared_ptr< SDLPP::Renderer > g_renderer = nullptr;
bool g_quit = false;
bool g_update_size = false;
std::vector<mapColumnType> g_objects = {};
std::vector< mapColumnType > g_objects = {};
std::mutex g_destruction_mutex;
// current mouse flags, previous mouse flags, selected edit box, selected tool box
std::tuple<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;
uint64_t g_current_block = 0;
std::vector<std::shared_ptr<SDLPP::RenderObject>> g_tools{};
std::shared_ptr<SDLPP::RenderObject> g_current_tool = nullptr;
std::vector< std::shared_ptr< SDLPP::RenderObject > > g_tools{};
std::shared_ptr< SDLPP::RenderObject > g_current_tool = nullptr;
int g_current_tool_index = 0;
int g_max_tool_index = 0;
std::shared_ptr<SDLPP::Texture> g_placeholder_texture = nullptr;
std::shared_ptr<SDLPP::Texture> g_placeholder_mario = nullptr;
std::shared_ptr< SDLPP::Texture > g_placeholder_texture = nullptr;
std::shared_ptr< SDLPP::Texture > g_placeholder_mario = nullptr;
std::shared_ptr<SDLPP::RenderObject> g_mario = nullptr;
SDLPP::Vec2D<int> g_mario_pos = {0,0};
std::shared_ptr< SDLPP::RenderObject > g_mario = nullptr;
SDLPP::Vec2D< int > g_mario_pos = { 0, 0 };
enum LandType::Value g_current_world_type = LandType::OVERWORLD;
void updateTool() {
auto tool_role = getBlockRole(possibleBlocks[g_current_block]);
std::shared_ptr<SDLPP::Texture> target_texture = nullptr;
switch(tool_role) {
case BlockRole::TERRAIN:
target_texture = g_placeholder_texture;
break;
case BlockRole::MARIO:
target_texture = g_placeholder_mario;
break;
case BlockRole::MODIFIER:
break;
case BlockRole::CHARACTER:
break;
auto tool_role = getBlockRole( possibleBlocks[g_current_block] );
std::shared_ptr< SDLPP::Texture > target_texture = nullptr;
switch ( tool_role ) {
case BlockRole::TERRAIN:
target_texture = g_placeholder_texture;
break;
case BlockRole::MARIO:
target_texture = g_placeholder_mario;
break;
case BlockRole::MODIFIER:
break;
case BlockRole::CHARACTER:
break;
}
g_current_tool->setTexture(target_texture, getSourceRectByID(possibleBlocks[g_current_block], g_current_world_type));
g_current_tool->setId(possibleBlocks[g_current_block]);
g_current_tool->getCollisions()[0]->setId(possibleBlocks[g_current_block]);
g_current_tool->setTexture(
target_texture, getSourceRectByID( possibleBlocks[g_current_block],
g_current_world_type ) );
g_current_tool->setId( possibleBlocks[g_current_block] );
g_current_tool->getCollisions()[0]->setId(
possibleBlocks[g_current_block] );
}
void removeMario() {
if(!g_mario)
if ( !g_mario )
return;
auto prev = g_objects[g_mario_pos.getX()][g_mario_pos.getY()];
// remove character/modifiers
g_objects[g_mario_pos.getX()][g_mario_pos.getY()] = {std::get<0>(prev), std::get<1>(prev), 0, 0, 0, 0};
g_objects[g_mario_pos.getX()][g_mario_pos.getY()] = {
std::get< 0 >( prev ), std::get< 1 >( prev ), 0, 0, 0, 0
};
g_mario->destroy();
}
void updateToolSelection(int prev_index) {
void updateToolSelection( int prev_index ) {
size_t prev = prev_index * 8;
size_t cur = g_current_tool_index * 8;
for(size_t i = prev; i < (g_tools.size() < prev + 8 ? g_tools.size() : prev + 8); i++) {
g_tools[i]->setHidden(true);
for ( size_t i = prev;
i < ( g_tools.size() < prev + 8 ? g_tools.size() : prev + 8 ); i++ ) {
g_tools[i]->setHidden( true );
}
for(size_t i = cur; i < (g_tools.size() < cur + 8 ? g_tools.size() : cur + 8); i++) {
g_tools[i]->setHidden(false);
for ( size_t i = cur;
i < ( g_tools.size() < cur + 8 ? g_tools.size() : cur + 8 ); i++ ) {
g_tools[i]->setHidden( false );
}
}
void moveToolsLeft() {
g_current_tool_index--;
updateToolSelection(g_current_tool_index + 1);
updateToolSelection( g_current_tool_index + 1 );
}
void moveToolsRight() {
g_current_tool_index++;
updateToolSelection(g_current_tool_index - 1);
updateToolSelection( g_current_tool_index - 1 );
}
// TODO add red outline to currently selected tool
// add WSAD navigation for the red highlight
void selectPrevTool() {
if(g_current_block == 0)
if ( g_current_block == 0 )
return;
if(g_current_block % 8 == 0) {
if ( g_current_block % 8 == 0 ) {
moveToolsLeft();
}
g_current_block--;
@@ -119,9 +128,9 @@ void selectPrevTool() {
}
void selectNextTool() {
if(g_current_block == g_tools.size() - 1)
if ( g_current_block == g_tools.size() - 1 )
return;
if(g_current_block % 8 == 7) {
if ( g_current_block % 8 == 7 ) {
moveToolsRight();
}
g_current_block++;
@@ -147,50 +156,57 @@ void handleKeyUp( SDL_Keycode key, SDLPP::Scene &scene ) {
}
}
void getMousePositionFlags(SDLPP::Scene &scene) {
auto mouse = scene.getObjects({EDITOR_MOUSE_ID})[0];
void getMousePositionFlags( SDLPP::Scene &scene ) {
auto mouse = scene.getObjects( { EDITOR_MOUSE_ID } )[0];
// move mouse colider to mouse position
mouse->setPos(SDLPP::Mouse::getMousePositionDouble(scene.getRenderer(), SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER));
mouse->setPos( SDLPP::Mouse::getMousePositionDouble(
scene.getRenderer(), SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ) );
MouseVisitor visitor;
scene.visitCollisions(*mouse, visitor);
std::get<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();
scene.visitCollisions( *mouse, visitor );
std::get< MouseInfo::CUR_FLAGS >( g_mouse_info ) = visitor.getFlags();
std::get< MouseInfo::EDIT_BOX >( g_mouse_info ) =
visitor.getEditBoxIndexes();
std::get< MouseInfo::TOOL_BOX >( g_mouse_info ) =
visitor.getToolBoxIndexes();
// if we found an edit box, move tool icon to that box
if(visitor.foundEditBox()) {
const auto &box = std::get<MouseInfo::EDIT_BOX>(g_mouse_info);
g_current_tool->setPos(BLOCK_SIZE + box.getX() * BLOCK_SIZE, 4*BLOCK_SIZE + box.getY() * BLOCK_SIZE);
if ( visitor.foundEditBox() ) {
const auto &box = std::get< MouseInfo::EDIT_BOX >( g_mouse_info );
g_current_tool->setPos( BLOCK_SIZE + box.getX() * BLOCK_SIZE,
4 * BLOCK_SIZE + box.getY() * BLOCK_SIZE );
}
}
void mouseUpAction(uint64_t flags, SDLPP::Scene &scene) {
if(MouseVisitor::moveMapLeft(flags) && g_current_start_index != 0) {
void mouseUpAction( uint64_t flags, SDLPP::Scene &scene ) {
if ( MouseVisitor::moveMapLeft( flags ) && g_current_start_index != 0 ) {
g_current_start_index -= 1;
scene.moveEverything(BLOCK_SIZE, 0);
scene.moveEverything( BLOCK_SIZE, 0 );
}
if(MouseVisitor::moveMapRight(flags)) {
if(g_current_start_index == g_current_max_index) {
if ( MouseVisitor::moveMapRight( flags ) ) {
if ( g_current_start_index == g_current_max_index ) {
// add column
// TODO 18 as constant
g_objects.resize(g_current_max_index + 18 + 1);
g_objects.resize( g_current_max_index + 18 + 1 );
g_current_max_index++;
}
g_current_start_index += 1;
scene.moveEverything(-BLOCK_SIZE,0);
scene.moveEverything( -BLOCK_SIZE, 0 );
}
if(MouseVisitor::moveToolsLeft(flags) && g_current_tool_index != 0) {
if ( MouseVisitor::moveToolsLeft( flags ) && g_current_tool_index != 0 ) {
g_current_tool_index -= 1;
updateToolSelection(g_current_tool_index + 1);
updateToolSelection( g_current_tool_index + 1 );
}
if(MouseVisitor::moveToolsRight(flags) && g_current_tool_index != g_max_tool_index) {
if ( MouseVisitor::moveToolsRight( flags ) &&
g_current_tool_index != g_max_tool_index ) {
g_current_tool_index += 1;
updateToolSelection(g_current_tool_index - 1);
updateToolSelection( g_current_tool_index - 1 );
}
}
SDLPP::Vec2D<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() };
SDLPP::Vec2D< int > getSelectedObjectPosition() {
return { g_current_start_index +
std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX(),
std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getY() };
}
mapObjectType &getSelectedObject() {
@@ -198,69 +214,75 @@ mapObjectType &getSelectedObject() {
return g_objects[pos.getX()][pos.getY()];
}
void placeTool(SDLPP::Scene &scene) {
std::lock_guard<std::mutex> lock(g_destruction_mutex);
void placeTool( SDLPP::Scene &scene ) {
std::lock_guard< std::mutex > lock( g_destruction_mutex );
ToolVisitor visitor;
auto tool_type = getBlockRole(g_current_tool->getId());
switch(tool_type) {
case BlockRole::TERRAIN:
visitor.setVisitorType(VisitorType::Terrain);
break;
default:
visitor.setVisitorType(VisitorType::Modifier);
break;
auto tool_type = getBlockRole( g_current_tool->getId() );
switch ( tool_type ) {
case BlockRole::TERRAIN:
visitor.setVisitorType( VisitorType::Terrain );
break;
default:
visitor.setVisitorType( VisitorType::Modifier );
break;
}
scene.visitCollisions(*g_current_tool, visitor);
if(visitor.removeBlock() && !visitor.addBlock()) {
scene.visitCollisions( *g_current_tool, visitor );
if ( visitor.removeBlock() && !visitor.addBlock() ) {
auto &obj = getSelectedObject();
switch(visitor.getVisitorType()) {
case VisitorType::Terrain:
std::get<MapObject::TERRAIN_TYPE>(obj) = LandType::OVERWORLD;
std::get<MapObject::TERRAIN_ID>(obj) = 0;
break;
case VisitorType::Modifier:
std::get<MapObject::CHARACTER_TYPE>(obj) = 0;
std::get<MapObject::CHARACTER_ID>(obj) = 0;
std::get<MapObject::MODIFIER_TYPE>(obj) = 0;
std::get<MapObject::MODIFIER_DATA>(obj) = 0;
break;
default:
break;
switch ( visitor.getVisitorType() ) {
case VisitorType::Terrain:
std::get< MapObject::TERRAIN_TYPE >( obj ) = LandType::OVERWORLD;
std::get< MapObject::TERRAIN_ID >( obj ) = 0;
break;
case VisitorType::Modifier:
std::get< MapObject::CHARACTER_TYPE >( obj ) = 0;
std::get< MapObject::CHARACTER_ID >( obj ) = 0;
std::get< MapObject::MODIFIER_TYPE >( obj ) = 0;
std::get< MapObject::MODIFIER_DATA >( obj ) = 0;
break;
default:
break;
}
} else if(visitor.addBlock()) {
} else if ( visitor.addBlock() ) {
auto &obj = getSelectedObject();
int z_index = 1;
std::shared_ptr<SDLPP::RenderObject> new_obj = nullptr;
switch(visitor.getVisitorType()) {
case VisitorType::Terrain:
std::get<MapObject::TERRAIN_TYPE>(obj) = LandType::OVERWORLD;
std::get<MapObject::TERRAIN_ID>(obj) = g_current_tool->getId();
// TODO why 1 +?
new_obj = createTerrainBlock(g_current_tool->getId(), LandType::OVERWORLD, g_renderer, 1 + std::get<MouseInfo::EDIT_BOX>(g_mouse_info).getX(), std::get<MouseInfo::EDIT_BOX>(g_mouse_info).getY(), true);
new_obj->getCollisions()[0]->setId(EDITOR_TERRAIN_ID);
break;
case VisitorType::Modifier:
// TODO check if modifier or character
std::get<MapObject::CHARACTER_TYPE>(obj) = LandType::OVERWORLD;
// TODO character ID
std::get<MapObject::CHARACTER_ID>(obj) = MARIO_ID;
std::get<MapObject::MODIFIER_TYPE>(obj) = 0;
std::get<MapObject::MODIFIER_DATA>(obj) = 0;
new_obj = createMario(LandType::OVERWORLD, g_renderer, 1 + std::get<MouseInfo::EDIT_BOX>(g_mouse_info).getX(), std::get<MouseInfo::EDIT_BOX>(g_mouse_info).getY());
// remove mario if exists
removeMario();
g_mario = new_obj;
g_mario_pos = getSelectedObjectPosition();
new_obj->getCollisions()[0]->setId(EDITOR_CHARACTER_ID);
z_index = scene.getObjects().size() - 1;
break;
default:
break;
std::shared_ptr< SDLPP::RenderObject > new_obj = nullptr;
switch ( visitor.getVisitorType() ) {
case VisitorType::Terrain:
std::get< MapObject::TERRAIN_TYPE >( obj ) = LandType::OVERWORLD;
std::get< MapObject::TERRAIN_ID >( obj ) = g_current_tool->getId();
// TODO why 1 +?
new_obj = createTerrainBlock(
g_current_tool->getId(), LandType::OVERWORLD, g_renderer,
1 + std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX(),
std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getY(), true );
new_obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID );
break;
case VisitorType::Modifier:
// TODO check if modifier or character
std::get< MapObject::CHARACTER_TYPE >( obj ) = LandType::OVERWORLD;
// TODO character ID
std::get< MapObject::CHARACTER_ID >( obj ) = MARIO_ID;
std::get< MapObject::MODIFIER_TYPE >( obj ) = 0;
std::get< MapObject::MODIFIER_DATA >( obj ) = 0;
new_obj = createMario(
LandType::OVERWORLD, g_renderer,
1 + std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX(),
std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getY() );
// remove mario if exists
removeMario();
g_mario = new_obj;
g_mario_pos = getSelectedObjectPosition();
new_obj->getCollisions()[0]->setId( EDITOR_CHARACTER_ID );
z_index = scene.getObjects().size() - 1;
break;
default:
break;
}
scene.addObject(new_obj);
scene.setZIndex(new_obj, z_index);
scene.addObject( new_obj );
scene.setZIndex( new_obj, z_index );
}
}
@@ -280,19 +302,24 @@ void pollEvents( SDLPP::Scene &scene ) {
}
break;
case SDL_MOUSEMOTION:
getMousePositionFlags(scene);
getMousePositionFlags( scene );
break;
case SDL_MOUSEBUTTONUP:
if(std::get<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) {
placeTool(scene);
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()) {
if ( index < g_tools.size() ) {
g_current_block = g_current_tool_index * 8 + index;
updateTool();
}
@@ -300,7 +327,8 @@ void pollEvents( SDLPP::Scene &scene ) {
break;
case SDL_MOUSEBUTTONDOWN:
// store current mouse flags in previous mouse flags
std::get<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,159 +379,180 @@ int main() {
// grid
for ( int i = 1; i < 20; i++ ) {
auto line_vertical = std::make_shared< SDLPP::LineRenderer >(
i * BLOCK_SIZE, 1 - 16 * BLOCK_SIZE, i * BLOCK_SIZE, 1.0, g_renderer, "#282828" );
i * BLOCK_SIZE, 1 - 16 * BLOCK_SIZE, i * BLOCK_SIZE, 1.0,
g_renderer, "#282828" );
line_vertical->setPermanent();
line_vertical->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
scene->addObject(line_vertical);
if(i > 2) {
scene->addObject( line_vertical );
if ( i > 2 ) {
auto line_horizontal = std::make_shared< SDLPP::LineRenderer >(
BLOCK_SIZE, ( i + 1 ) * BLOCK_SIZE, 19 * BLOCK_SIZE,
( i + 1 ) * BLOCK_SIZE, g_renderer, "#282828" );
line_horizontal->setPermanent();
line_horizontal->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
scene->addObject(line_horizontal);
line_horizontal->setAlignment( SDLPP::OBJ_CENTER,
SDLPP::OBJ_CENTER );
scene->addObject( line_horizontal );
}
}
// white rectangles
auto rectangle1 = std::make_shared< SDLPP::RectangleRender >(
0, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE, g_renderer, "#FFFFFF88", true);
rectangle1->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
rectangle1->setId(EDITOR_LEFT_MAP_ID);
0, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE, g_renderer, "#FFFFFF88",
true );
rectangle1->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
rectangle1->setId( EDITOR_LEFT_MAP_ID );
rectangle1->setPermanent();
rectangle1->addCollision(SDLPP::RectColider(0, 0, 1, 1));
scene->addObject(rectangle1);
rectangle1->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) );
scene->addObject( rectangle1 );
// white rectangles
auto rectangle2 = std::make_shared< SDLPP::RectangleRender >(
19*BLOCK_SIZE, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE, g_renderer, "#FFFFFF88", true);
rectangle2->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
rectangle2->setId(EDITOR_RIGHT_MAP_ID);
19 * BLOCK_SIZE, 4 * BLOCK_SIZE, BLOCK_SIZE, 16 * BLOCK_SIZE,
g_renderer, "#FFFFFF88", true );
rectangle2->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
rectangle2->setId( EDITOR_RIGHT_MAP_ID );
rectangle2->setPermanent();
rectangle2->addCollision(SDLPP::RectColider(0, 0, 1, 1));
scene->addObject(rectangle2);
rectangle2->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) );
scene->addObject( rectangle2 );
auto font = std::make_shared< SDLPP::Font >( "testfont.ttf", 36 );
auto font_config = std::make_shared< SDLPP::FontConfiguration >(
font, "#000000", "#282828", 0.05 );
auto left = std::make_shared< SDLPP::TextRenderer >(
0, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, "<", font_config);
left->setId(0);
left->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
0, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, "<",
font_config );
left->setId( 0 );
left->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
left->setPermanent();
scene->addObject(left);
scene->addObject( left );
auto right = std::make_shared< SDLPP::TextRenderer >(
19*BLOCK_SIZE, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, ">", font_config);
right->setId(0);
right->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
19 * BLOCK_SIZE, 11.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer,
">", font_config );
right->setId( 0 );
right->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
right->setPermanent();
scene->addObject(right);
scene->addObject( right );
for(int i = 0; i < 18; i++) {
for(int j = 0; j < 16; j++) {
scene->addObject(std::make_shared<EditBox>(i, j, g_renderer));
for ( int i = 0; i < 18; i++ ) {
for ( int j = 0; j < 16; j++ ) {
scene->addObject( std::make_shared< EditBox >( i, j, g_renderer ) );
}
}
auto mouse =
std::make_shared< SDLPP::RectangleRender >( 0.01, 0.01, 0, 0, g_renderer );
mouse->setMinWidth(1);
mouse->setMinHeight(1);
auto mouse = std::make_shared< SDLPP::RectangleRender >( 0.01, 0.01, 0, 0,
g_renderer );
mouse->setMinWidth( 1 );
mouse->setMinHeight( 1 );
mouse->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
mouse->setId( EDITOR_MOUSE_ID );
mouse->setColiderColor("#00FF00");
mouse->addCollision(
SDLPP::RectColider( { 0, 0 }, { 1, 1 } ) );
mouse->setColiderColor( "#00FF00" );
mouse->addCollision( SDLPP::RectColider( { 0, 0 }, { 1, 1 } ) );
scene->addObject( mouse );
g_current_max_index = g_objects.size() - 18;
// tools
g_max_tool_index = (possibleBlocks.size() - 1) / 8;
for(int i = 0; i < 4; i++) {
auto tool_box1 = std::make_shared<ToolBox>(i, 0, g_renderer);
auto tool_box2 = std::make_shared<ToolBox>(i, 1, g_renderer);
scene->addObject(tool_box1);
scene->addObject(tool_box2);
// std::cout << "TOOL BOX POS: " << tool_box1->getPos().getX() << ", " << tool_box1->getPos().getY() << std::endl;
// std::cout << "TOOL BOX POS: " << tool_box2->getPos().getX() << ", " << tool_box2->getPos().getY() << std::endl;
g_max_tool_index = ( possibleBlocks.size() - 1 ) / 8;
for ( int i = 0; i < 4; i++ ) {
auto tool_box1 = std::make_shared< ToolBox >( i, 0, g_renderer );
auto tool_box2 = std::make_shared< ToolBox >( i, 1, g_renderer );
scene->addObject( tool_box1 );
scene->addObject( tool_box2 );
// std::cout << "TOOL BOX POS: " << tool_box1->getPos().getX() <<
// ", " << tool_box1->getPos().getY() << std::endl; std::cout <<
// "TOOL BOX POS: " << tool_box2->getPos().getX() << ", " <<
// tool_box2->getPos().getY() << std::endl;
}
int tool_index = 0;
for(auto &block : possibleBlocks) {
if(block == MARIO_ID ) {
g_tools.push_back(createMario(LandType::OVERWORLD, g_renderer, 0, 0));
for ( auto &block : possibleBlocks ) {
if ( block == MARIO_ID ) {
g_tools.push_back(
createMario( LandType::OVERWORLD, g_renderer, 0, 0 ) );
} else {
g_tools.push_back(createTerrainBlock(block, LandType::OVERWORLD, g_renderer, false));
g_tools.push_back( createTerrainBlock( block, LandType::OVERWORLD,
g_renderer, false ) );
}
g_tools.back()->setHidden(true);
g_tools.back()->setHidden( true );
g_tools.back()->setPermanent();
auto x = tool_index % 4;
auto y = tool_index / 4;
// TODO add 14 and 1 as constants somewhere
// TODO investigate when not permanent requires `-1` on x position
g_tools.back()->setPos(14*BLOCK_SIZE + x*BLOCK_SIZE, BLOCK_SIZE + y*BLOCK_SIZE);
// std::cout << "TOOL POS: " << tools.back()->getPos().getX() << ", " << tools.back()->getPos().getY() << std::endl;
scene->addObject(g_tools.back());
tool_index = (tool_index + 1) % 8;
g_tools.back()->setPos( 14 * BLOCK_SIZE + x * BLOCK_SIZE,
BLOCK_SIZE + y * BLOCK_SIZE );
// std::cout << "TOOL POS: " << tools.back()->getPos().getX() <<
// ", " << tools.back()->getPos().getY() << std::endl;
scene->addObject( g_tools.back() );
tool_index = ( tool_index + 1 ) % 8;
}
for(int i = 0; i < 5; i++) {
auto line = std::make_shared<SDLPP::LineRenderer>(
14*BLOCK_SIZE + i*BLOCK_SIZE, BLOCK_SIZE, 14 * BLOCK_SIZE + i*BLOCK_SIZE, 3*BLOCK_SIZE, g_renderer, "#282828");
for ( int i = 0; i < 5; i++ ) {
auto line = std::make_shared< SDLPP::LineRenderer >(
14 * BLOCK_SIZE + i * BLOCK_SIZE, BLOCK_SIZE,
14 * BLOCK_SIZE + i * BLOCK_SIZE, 3 * BLOCK_SIZE, g_renderer,
"#282828" );
line->setPermanent();
line->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
scene->addObject(line);
line->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
scene->addObject( line );
}
for(int i = 0; i < 3; i++) {
auto line = std::make_shared<SDLPP::LineRenderer>(
14*BLOCK_SIZE, BLOCK_SIZE + i*BLOCK_SIZE, 14 * BLOCK_SIZE + 4*BLOCK_SIZE, BLOCK_SIZE + i*BLOCK_SIZE, g_renderer, "#282828");
for ( int i = 0; i < 3; i++ ) {
auto line = std::make_shared< SDLPP::LineRenderer >(
14 * BLOCK_SIZE, BLOCK_SIZE + i * BLOCK_SIZE,
14 * BLOCK_SIZE + 4 * BLOCK_SIZE, BLOCK_SIZE + i * BLOCK_SIZE,
g_renderer, "#282828" );
line->setPermanent();
line->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
scene->addObject(line);
line->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
scene->addObject( line );
}
auto tool_rect1 = std::make_shared< SDLPP::RectangleRender >(
13*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, g_renderer, "#FFFFFF88", true);
tool_rect1->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
tool_rect1->setId(EDITOR_LEFT_TOOL_ID);
13 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, g_renderer,
"#FFFFFF88", true );
tool_rect1->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
tool_rect1->setId( EDITOR_LEFT_TOOL_ID );
tool_rect1->setPermanent();
tool_rect1->addCollision(SDLPP::RectColider(0, 0, 1, 1));
scene->addObject(tool_rect1);
tool_rect1->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) );
scene->addObject( tool_rect1 );
// white rectangles
auto tool_rect2 = std::make_shared< SDLPP::RectangleRender >(
18*BLOCK_SIZE, 1 * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, g_renderer, "#FFFFFF88", true);
tool_rect2->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
tool_rect2->setId(EDITOR_RIGHT_TOOL_ID);
18 * BLOCK_SIZE, 1 * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, g_renderer,
"#FFFFFF88", true );
tool_rect2->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
tool_rect2->setId( EDITOR_RIGHT_TOOL_ID );
tool_rect2->setPermanent();
tool_rect2->addCollision(SDLPP::RectColider(0, 0, 1, 1));
scene->addObject(tool_rect2);
tool_rect2->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) );
scene->addObject( tool_rect2 );
auto left_tool = std::make_shared< SDLPP::TextRenderer >(
13*BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, "<", font_config);
left_tool->setId(0);
left_tool->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
13 * BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer,
"<", font_config );
left_tool->setId( 0 );
left_tool->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
left_tool->setPermanent();
scene->addObject(left_tool);
scene->addObject( left_tool );
auto right_tool = std::make_shared< SDLPP::TextRenderer >(
18*BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, ">", font_config);
right_tool->setId(0);
right_tool->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
18 * BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer,
">", font_config );
right_tool->setId( 0 );
right_tool->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
right_tool->setPermanent();
scene->addObject(right_tool);
scene->addObject( right_tool );
g_placeholder_texture = std::make_shared< SDLPP::Texture >(
g_renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY );
g_placeholder_texture->setAlpha(100);
g_placeholder_texture->setAlpha( 100 );
g_placeholder_mario = std::make_shared< SDLPP::Texture >(
g_renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY );
g_placeholder_mario->setAlpha(100);
g_current_tool = createTerrainBlock(possibleBlocks[g_current_block], LandType::OVERWORLD, g_renderer, g_placeholder_texture, false);
g_current_tool->addCollision(SDLPP::RectColider(0.1, 0.1, 0.8, 0.8));
dynamic_cast<MarioBlock&>(*g_current_tool).setTool();
scene->addObject(g_current_tool);
scene->moveZTop(g_current_tool);
g_placeholder_mario->setAlpha( 100 );
g_current_tool = createTerrainBlock( possibleBlocks[g_current_block],
LandType::OVERWORLD, g_renderer,
g_placeholder_texture, false );
g_current_tool->addCollision( SDLPP::RectColider( 0.1, 0.1, 0.8, 0.8 ) );
dynamic_cast< MarioBlock & >( *g_current_tool ).setTool();
scene->addObject( g_current_tool );
scene->moveZTop( g_current_tool );
scene->moveEverything(BLOCK_SIZE, 0);
scene->moveEverything( BLOCK_SIZE, 0 );
FPSmanager gFPS;
SDL_initFramerate( &gFPS );
SDL_setFramerate( &gFPS, 60 );
updateToolSelection(0);
updateToolSelection( 0 );
auto base = SDL_GetTicks();
int frames = 0;
@@ -512,7 +561,7 @@ int main() {
while ( !g_quit ) {
SDL_PumpEvents();
SDL_framerateDelay( &gFPS );
std::lock_guard<std::mutex> lock(g_destruction_mutex);
std::lock_guard< std::mutex > lock( g_destruction_mutex );
scene->renderScene();
g_renderer->presentRenderer();
frames++;
@@ -521,33 +570,33 @@ int main() {
frames = 0;
base = SDL_GetTicks();
}
if(g_current_start_index == 0) {
left->setTextColor(font, "#CCCCCC", "#CCCCCC", 0.05);
if ( g_current_start_index == 0 ) {
left->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 );
} else {
left->setTextColor(font, "#000000", "#282828", 0.05);
left->setTextColor( font, "#000000", "#282828", 0.05 );
}
if(g_current_start_index == g_current_max_index) {
right->setTextColor(font, "#00FF00", "#000000", 0.1);
right->changeText("+");
if ( g_current_start_index == g_current_max_index ) {
right->setTextColor( font, "#00FF00", "#000000", 0.1 );
right->changeText( "+" );
} else {
right->setTextColor(font, "#000000", "#282828", 0.05);
right->changeText(">");
right->setTextColor( font, "#000000", "#282828", 0.05 );
right->changeText( ">" );
}
if(g_current_tool_index == 0) {
left_tool->setTextColor(font, "#CCCCCC", "#CCCCCC", 0.05);
if ( g_current_tool_index == 0 ) {
left_tool->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 );
} else {
left_tool->setTextColor(font, "#000000", "#282828", 0.05);
left_tool->setTextColor( font, "#000000", "#282828", 0.05 );
}
if(g_current_tool_index == g_max_tool_index) {
right_tool->setTextColor(font, "#CCCCCC", "#CCCCCC", 0.05);
if ( g_current_tool_index == g_max_tool_index ) {
right_tool->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 );
} else {
right_tool->setTextColor(font, "#000000", "#282828", 0.05);
right_tool->setTextColor( font, "#000000", "#282828", 0.05 );
}
if(g_update_size) {
if ( g_update_size ) {
scene->updateSizeAndPosition();
}
}
saveMap("test_binary2.bin", g_objects);
saveMap( "test_binary2.bin", g_objects );
return 0;
}