diff --git a/mario/blocks.cpp b/mario/blocks.cpp index bf40e54..e191f1f 100644 --- a/mario/blocks.cpp +++ b/mario/blocks.cpp @@ -17,88 +17,91 @@ #define CAN_BE_DESTROYED_FLAG 0x0000000000000001 #define HAS_COLLISION 0x0000000000000002 -MarioBlock::MarioBlock( int x, int y, - const std::shared_ptr< SDLPP::Renderer > &renderer, - std::shared_ptr< SDLPP::Texture > texture, SDL_Rect src, - bool can_be_destroyed, bool destructible ) - : RectangleRender( x * BLOCK_SIZE, 1 - ( 16 - y ) * BLOCK_SIZE, - BLOCK_SIZE, BLOCK_SIZE, renderer, texture, src ) { +MarioBlock::MarioBlock(int x, int y, + const std::shared_ptr &renderer, + std::shared_ptr texture, SDL_Rect src, + bool can_be_destroyed, bool destructible) + : RectangleRender(x * BLOCK_SIZE, 1 - (16 - y) * BLOCK_SIZE, BLOCK_SIZE, + BLOCK_SIZE, renderer, texture, src) { _can_be_destroyed = can_be_destroyed; _destructible = can_be_destroyed && destructible; - setMovementSpeed( 1 ); + setMovementSpeed(1); _coins = 0; _mushroom = false; _base_src = src; } -void MarioBlock::visit( SDLPP::Visitor &visitor ) { +void MarioBlock::visit(SDLPP::Visitor &visitor) { #ifdef EDITOR - if ( !_tool && _terrain && - visitor.getVisitorType() == VisitorType::Terrain ) { + if (!_tool && _terrain && + visitor.getVisitorType() == VisitorType::Terrain) { destroy(); } - if ( !_tool && !_terrain && - (visitor.getVisitorType() == VisitorType::Modifier || - visitor.getVisitorType() == VisitorType::Character)) { + if (!_tool && !_terrain && + (visitor.getVisitorType() == VisitorType::Modifier || + visitor.getVisitorType() == VisitorType::Character)) { destroy(); } #else - if ( visitor.getFromId() == MARIO_TOP_DETECT && - dynamic_cast< MarioVisitor & >( visitor ).canDestroy() ) { + if (visitor.getFromId() == MARIO_TOP_DETECT && + dynamic_cast(visitor).canDestroy()) { // TODO if big mario and _can_be_destroyed - if ( _destructible && !hasCoin() ) { + if (_destructible && !hasCoin()) { destroy(); } else { BounceVisitor bv; - bv.setVisitorType( VisitorType::Terrain ); + bv.setVisitorType(VisitorType::Terrain); - setPos( getPos() - SDLPP::Vec2D< double >( 0, BLOCK_SIZE ) ); - if ( getCollisions().size() < 2 ) - addCollision( SDLPP::RectColider( 0.1, 0.1, 0.8, 0.8, BOUNCE_COLLISION ) ); + setPos(getPos() - SDLPP::Vec2D(0, BLOCK_SIZE)); + if (getCollisions().size() < 2) + addCollision( + SDLPP::RectColider(0.1, 0.1, 0.8, 0.8, BOUNCE_COLLISION)); updateSizeAndPosition(); - g_playground->visitCollisions( *this, bv ); - setPos( getPos() + SDLPP::Vec2D< double >( 0, BLOCK_SIZE ) ); + g_playground->visitCollisions(*this, bv); + setPos(getPos() + SDLPP::Vec2D(0, BLOCK_SIZE)); updateSizeAndPosition(); - if ( bv.canBounce() ) + if (bv.canBounce()) bounce(); } - if ( hasCoin() ) { + if (hasCoin()) { removeCoin(); - auto coin = createTerrainBlock(COIN_ID, LandType::OVERWORLD, renderer); + auto coin = + createTerrainBlock(COIN_ID, LandType::OVERWORLD, renderer); coin->setPos(getPos()); std::dynamic_pointer_cast(coin)->setParent(this); - dynamic_cast< MarioVisitor & >( visitor ).setCoin(); - dynamic_cast< MarioVisitor & >( visitor ).setCoinBlock(coin); + dynamic_cast(visitor).setCoin(); + dynamic_cast(visitor).setCoinBlock(coin); } - if ( hasMushroom() ) { + if (hasMushroom()) { removeMushroom(); - auto mushroom = createTerrainBlock(MUSHROOM_ID, LandType::OVERWORLD, renderer); + auto mushroom = + createTerrainBlock(MUSHROOM_ID, LandType::OVERWORLD, renderer); mushroom->setPos(getPos()); std::dynamic_pointer_cast(mushroom)->setParent(this); - dynamic_cast< MarioVisitor & >( visitor ).setMushroomBlock(mushroom); + dynamic_cast(visitor).setMushroomBlock(mushroom); } } #endif - visitor.visit( *this ); + visitor.visit(*this); } -void MarioBlock::setTool( bool tool ) { +void MarioBlock::setTool(bool tool) { _tool = tool; } -void MarioBlock::setTerrain( bool terrain ) { +void MarioBlock::setTerrain(bool terrain) { _terrain = terrain; } void MarioBlock::bounce() { - if ( _bouncing ) { + if (_bouncing) { return; } _bouncing = true; og_pos = getPos(); ticks_to_bounce = bounce_ticks; - setMovement( 0, -bounce_speed ); + setMovement(0, -bounce_speed); } void MarioBlock::travelToPos(const SDLPP::Vec2D &target) { - if(_traveling) { + if (_traveling) { return; } _traveling = true; @@ -106,11 +109,11 @@ void MarioBlock::travelToPos(const SDLPP::Vec2D &target) { auto movement = (_target - getPos()); auto abs_mov_x = movement.getX(); - if(abs_mov_x < 0) { + if (abs_mov_x < 0) { abs_mov_x *= -1; } auto abs_mov_y = movement.getY(); - if(abs_mov_y < 0) { + if (abs_mov_y < 0) { abs_mov_y *= -1; } @@ -120,11 +123,11 @@ void MarioBlock::travelToPos(const SDLPP::Vec2D &target) { } void MarioBlock::gravity(int ticks) { - if(_on_ground) { + if (_on_ground) { return; } _ticks_till_gravity -= ticks; - if(_ticks_till_gravity < 0) { + if (_ticks_till_gravity < 0) { addMovement(0, _gravity_acceleration); _ticks_till_gravity = _base_gravity_ticks; } @@ -138,51 +141,49 @@ bool MarioBlock::isTraveling() const { return _traveling; } -void MarioBlock::custom_move( int ticks ) { - if ( !_bouncing && !_traveling ) { +void MarioBlock::custom_move(int ticks) { + if (!_bouncing && !_traveling) { return; } - if( _bouncing ) { - if ( getMovement().getY() < 0 ) { + if (_bouncing) { + if (getMovement().getY() < 0) { ticks_to_bounce -= ticks; - if ( ticks_to_bounce < 0 ) { - setMovement( 0, bounce_speed ); + if (ticks_to_bounce < 0) { + setMovement(0, bounce_speed); ticks_to_bounce = bounce_ticks; } } else { - if ( getPos().getY() >= og_pos.getY() ) { - setMovement( 0, 0 ); - setPos( getPos().getX(), og_pos.getY() ); + if (getPos().getY() >= og_pos.getY()) { + setMovement(0, 0); + setPos(getPos().getX(), og_pos.getY()); _bouncing = false; } } } - if(_traveling) { - bool overshot_x = (getMovement().getX() < 0 && - getPos().getX() <= _target.getX()) || - (getMovement().getX() > 0 && - getPos().getX() >= _target.getX()); - bool overshot_y = (getMovement().getY() < 0 && - getPos().getY() <= _target.getY()) || - (getMovement().getY() > 0 && - getPos().getY() >= _target.getY()); - if(overshot_x) { + if (_traveling) { + bool overshot_x = + (getMovement().getX() < 0 && getPos().getX() <= _target.getX()) || + (getMovement().getX() > 0 && getPos().getX() >= _target.getX()); + bool overshot_y = + (getMovement().getY() < 0 && getPos().getY() <= _target.getY()) || + (getMovement().getY() > 0 && getPos().getY() >= _target.getY()); + if (overshot_x) { setPos(_target.getX(), getPos().getY()); setMovement(0, getMovement().getY()); } - if(overshot_y) { + if (overshot_y) { setPos(getPos().getX(), _target.getY()); setMovement(getMovement().getX(), 0); } - if(getMovement() == SDLPP::Vec2D(0,0)) { + if (getMovement() == SDLPP::Vec2D(0, 0)) { _traveling = false; } } } -void MarioBlock::setType( LandType::Value type ) { +void MarioBlock::setType(LandType::Value type) { _type = type; - setWorldTypeSrc( _type ); + setWorldTypeSrc(_type); } LandType::Value MarioBlock::getType() const { return _type; @@ -203,20 +204,20 @@ void MarioBlock::removeMushroom() { void MarioBlock::addMushroom() { _mushroom = true; } -void MarioBlock::setCoinCount( int coins ) { +void MarioBlock::setCoinCount(int coins) { _coins = coins; } -void MarioBlock::setDestructible( bool destructible ) { +void MarioBlock::setDestructible(bool destructible) { _destructible = destructible; } void MarioBlock::ensureCollision() { - if ( getCollisions().size() == 0 ) { - addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) ); + if (getCollisions().size() == 0) { + addCollision(SDLPP::RectColider(0, 0, 1, 1)); } } -void MarioBlock::setWorldTypeSrc( LandType::Value world ) { +void MarioBlock::setWorldTypeSrc(LandType::Value world) { auto rect = _base_src; - switch ( world ) { + switch (world) { case LandType::OVERWORLD: rect.x += OVERWORLD_SHIFT.getX(); rect.y += OVERWORLD_SHIFT.getY(); @@ -234,10 +235,10 @@ void MarioBlock::setWorldTypeSrc( LandType::Value world ) { rect.y += BOWSER_SHIFT.getY(); break; } - setTextureSourceRect( rect ); + setTextureSourceRect(rect); } -const std::vector< uint64_t > possibleBlocks = { +const std::vector possibleBlocks = { FLOOR_ID, STEP_ID, HILL_TOP_ID, @@ -298,362 +299,354 @@ const std::vector< uint64_t > possibleBlocks = { CANNON_ID, }; -const std::vector< uint64_t > possibleMods = { +const std::vector possibleMods = { DESTRUCTIBLE_MODIFIER_ID, BACKGROUND_MODIFIER_ID, COIN_MODIFIER_ID, MUSHROOM_MODIFIER_ID, }; -const std::vector< uint64_t > possibleCharacters = { +const std::vector possibleCharacters = { MARIO_ID, GOOMBA_ID, }; -const std::vector< LandType::Value > possibleLands = { +const std::vector possibleLands = { LandType::OVERWORLD, LandType::UNDERWORLD, LandType::WATER, LandType::BOWSER }; -std::shared_ptr< MarioBlock > -createBlockById( uint64_t id, int x, int y, - std::shared_ptr< SDLPP::Renderer > &renderer ) { - std::shared_ptr< MarioBlock > result = nullptr; - switch ( id ) { +std::shared_ptr +createBlockById(uint64_t id, int x, int y, + std::shared_ptr &renderer) { + std::shared_ptr result = nullptr; + switch (id) { case FLOOR_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< FloorBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case HILL_INCLINE_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< HillInclineBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case HILL_DECLINE_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< HillDeclineBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case HILL_DOTS_RIGHT_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< HillDotsRightBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case HILL_DOTS_LEFT_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< HillDotsLeftBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case HILL_FILL_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< HillFillBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case HILL_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< HillTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case BUSH_LEFT_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< BushLeftBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case BUSH_MIDDLE_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< BushMiddleBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case BUSH_RIGHT_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< BushRightBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CLOUD_LEFT_BOTTOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CloudLeftBottomBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CLOUD_MIDDLE_BOTTOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CloudMiddleBottomBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CLOUD_RIGHT_BOTTOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CloudRightBottomBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CLOUD_LEFT_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CloudLeftTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CLOUD_MIDDLE_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CloudMiddleTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CLOUD_RIGHT_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CloudRightTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case PIPE_LEFT_BOTTOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< PipeLeftBottomBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case PIPE_RIGHT_BOTTOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< PipeRightBottomBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case PIPE_LEFT_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< PipeLeftTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case PIPE_RIGHT_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< PipeRightTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CASTLE_LEFT_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CastleLeftBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CASTLE_RIGHT_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CastleRightBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CASTLE_BLACK_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CastleBlackBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CASTLE_ENTRY_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CastleEntryBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CASTLE_TOWER_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CastleTowerBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CASTLE_TOWER_FILLED_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CastleTowerFilledBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case VINE_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< VineTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case VINE_BOTTOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< VineBottomBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case POLE_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< PoleTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case POLE_BOTTOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< PoleBottomBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case FLAG_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< FlagBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case STEP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< StepBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case BRICK_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< BrickBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case BRICK_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< BrickTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case SIDEWAY_PIPE_END_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< SidewayPipeEndTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case SIDEWAY_PIPE_END_BOTTOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< SidewayPipeEndBottomBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case SIDEWAY_PIPE_MIDDLE_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< SidewayPipeMiddleTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case SIDEWAY_PIPE_MIDDLE_BOTTOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< SidewayPipeMiddleBottomBlock >( x, y, - renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case SIDEWAY_PIPE_CONNECTOR_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< SidewayPipeConnectorTopBlock >( x, y, - renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case SIDEWAY_PIPE_CONNECTOR_BOTTOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< SidewayPipeConnectorBottomBlock >( x, y, - renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case TREE_PLATFORM_TOP_LEFT_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< TreePlatformTopLeftBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case TREE_PLATFORM_TOP_MIDDLE_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< TreePlatformTopMiddleBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case TREE_PLATFORM_TOP_RIGHT_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< TreePlatformTopRightBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case TREE_PLATFORM_BARK_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< TreePlatformBarkBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case WATER_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< WaterTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case WATER_FILL_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< WaterFillBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case MUSHROOM_PLATFORM_TOP_LEFT_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< MushroomPlatformTopLeftBlock >( x, y, - renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case MUSHROOM_PLATFORM_TOP_MIDDLE_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< MushroomPlatformTopMiddleBlock >( x, y, - renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case MUSHROOM_PLATFORM_TOP_RIGHT_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< MushroomPlatformTopRightBlock >( x, y, - renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case MUSHROOM_PLATFORM_BARK_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< MushroomPlatformBarkTopBlock >( x, y, - renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case MUSHROOM_PLATFORM_BARK_BOTTOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< MushroomPlatformBarkBottomBlock >( x, y, - renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case TREE_BARK_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< TreeBarkBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case TREE_LEAVES_SMALL_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< TreeLeavesSmallBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case TREE_LEAVES_TOP_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< TreeLeavesTopBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case TREE_LEAVES_BOTTOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< TreeLeavesBottomBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CANNON_TOWER_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CannonTowerBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CANNON_PEDESTAL_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CannonPedestalBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case CANNON_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CannonBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case MARIO_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< Mario >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case GOOMBA_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< GoombaBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case DESTRUCTIBLE_MODIFIER_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< DestructibleModifierBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case BACKGROUND_MODIFIER_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< BackgroundModifierBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; #ifdef EDITOR case COIN_MODIFIER_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CoinEditorBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; #endif case MUSHROOM_MODIFIER_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< MushroomModifierBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; #ifndef EDITOR case COIN_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< CoinBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; case MUSHROOM_ID: - result = std::static_pointer_cast< MarioBlock >( - std::make_shared< MushroomBlock >( x, y, renderer ) ); + result = std::static_pointer_cast( + std::make_shared(x, y, renderer)); break; #endif } return result; } -std::shared_ptr< MarioBlock > -createBlock( std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y, - uint64_t id, LandType::Value land_type, bool destructible, - bool editor ) { - auto block = createBlockById( id, x, y, renderer ); - if ( block == nullptr ) { +std::shared_ptr +createBlock(std::shared_ptr &renderer, int x, int y, + uint64_t id, LandType::Value land_type, bool destructible, + bool editor) { + auto block = createBlockById(id, x, y, renderer); + if (block == nullptr) { return nullptr; } - block->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); + block->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); block->setStatic(); - block->setType( land_type ); - if ( destructible ) { + block->setType(land_type); + if (destructible) { block->setDestructible(); } - if ( editor ) { + if (editor) { block->ensureCollision(); } return block; } // TODO coin count -std::shared_ptr< MarioBlock > -createTerrainBlock( uint64_t block_id, LandType::Value type, - std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y, - bool destructible, bool editor ) { - return createBlock( renderer, x, y, block_id, type, destructible, editor ); +std::shared_ptr +createTerrainBlock(uint64_t block_id, LandType::Value type, + std::shared_ptr &renderer, int x, int y, + bool destructible, bool editor) { + return createBlock(renderer, x, y, block_id, type, destructible, editor); } -std::shared_ptr< MarioBlock > -createTerrainBlock( uint64_t block_id, LandType::Value type, - std::shared_ptr< SDLPP::Renderer > &renderer, - bool destructible, bool editor ) { - return createTerrainBlock( block_id, type, renderer, 0, 0, destructible, - editor ); +std::shared_ptr +createTerrainBlock(uint64_t block_id, LandType::Value type, + std::shared_ptr &renderer, + bool destructible, bool editor) { + return createTerrainBlock(block_id, type, renderer, 0, 0, destructible, + editor); } -std::shared_ptr< MarioBlock > -createMario( LandType::Value type, std::shared_ptr< SDLPP::Renderer > &renderer, - int x, int y, bool editor ) { +std::shared_ptr +createMario(LandType::Value type, std::shared_ptr &renderer, + int x, int y, bool editor) { // TODO add type additions - auto mario = createBlock( renderer, x, y, MARIO_ID, type, false, true ); - if ( editor ) { - mario->setTerrain( false ); + auto mario = createBlock(renderer, x, y, MARIO_ID, type, false, true); + if (editor) { + mario->setTerrain(false); mario->removeCollisions(); mario->ensureCollision(); } return mario; } -enum BlockRole::Value getBlockRole( uint64_t id ) { - if ( id >= 0x7000 ) +enum BlockRole::Value getBlockRole(uint64_t id) { + if (id >= 0x7000) return BlockRole::TERRAIN; - if ( id == MARIO_ID ) + if (id == MARIO_ID) return BlockRole::MARIO; - if ( id < MARIO_ID ) + if (id < MARIO_ID) return BlockRole::CHARACTER; return BlockRole::MODIFIER; } @@ -662,12 +655,14 @@ void MarioBlock::setBaseRect(SDL_Rect rect) { _base_src = rect; setType(getType()); } + void MarioBlock::checkVisibility(double rightmost_x) { // we assume that object's X > 0 as otherwise it would be destroyed - if(!getHidden() && getAbsolutePos().getX() < rightmost_x) { + if (!getHidden() && getAbsolutePos().getX() < rightmost_x) { _was_visible = true; } } + bool MarioBlock::wasVisible() const { return _was_visible; } diff --git a/mario/blocks.hpp b/mario/blocks.hpp index 0decef8..6574a56 100644 --- a/mario/blocks.hpp +++ b/mario/blocks.hpp @@ -11,24 +11,23 @@ struct LandType { class MarioBlock : public SDLPP::RectangleRender { public: - MarioBlock( int x, int y, - const std::shared_ptr< SDLPP::Renderer > &renderer, - std::shared_ptr< SDLPP::Texture > texture, SDL_Rect src, - bool can_be_destroyed = false, bool destructible = false ); - void visit( SDLPP::Visitor &visitor ) override; - void setTool( bool tool = true ); - void setTerrain( bool terrain = true ); + MarioBlock(int x, int y, const std::shared_ptr &renderer, + std::shared_ptr texture, SDL_Rect src, + bool can_be_destroyed = false, bool destructible = false); + void visit(SDLPP::Visitor &visitor) override; + void setTool(bool tool = true); + void setTerrain(bool terrain = true); void bounce(); void travelToPos(const SDLPP::Vec2D &target); - void custom_move( int ticks ) override; - void setType( LandType::Value type ); + void custom_move(int ticks) override; + void setType(LandType::Value type); LandType::Value getType() const; virtual void onScrollUp() {} virtual void onScrollDown() {} virtual uint8_t getData() const { return 0; } - virtual void setData( uint8_t /*UNUSED*/ ) {} + virtual void setData(uint8_t /*UNUSED*/) {} // handle own visitor virtual void handleVisitor(SDLPP::Visitor &visitor) {} bool hasCoin(); @@ -36,8 +35,8 @@ public: void removeCoin(); void removeMushroom(); void addMushroom(); - void setCoinCount( int coins ); - void setDestructible( bool destructible = true ); + void setCoinCount(int coins); + void setDestructible(bool destructible = true); void ensureCollision(); bool isBouncing() const; bool isTraveling() const; @@ -52,7 +51,7 @@ protected: void gravity(int ticks); void setOnGround(bool on_ground = true) { _on_ground = on_ground; - if(on_ground) { + if (on_ground) { setMovement(getMovement().getX(), 0); } } @@ -63,7 +62,7 @@ protected: _base_gravity_ticks = ticks; } - virtual void setWorldTypeSrc( LandType::Value world ); + virtual void setWorldTypeSrc(LandType::Value world); private: bool _tool = false; @@ -76,22 +75,22 @@ private: bool _mushroom = false; bool _release_coin = false; int ticks_to_bounce = 0; - SDLPP::Vec2D< double > og_pos = {}; + SDLPP::Vec2D og_pos = {}; LandType::Value _type; SDL_Rect _base_src; - SDLPP::Vec2D _target = {0,0}; + SDLPP::Vec2D _target = { 0, 0 }; bool _on_ground = true; int _base_gravity_ticks = 1000 / 60; int _ticks_till_gravity = 0; - double _gravity_acceleration = 1.0/(64.0/7.0); + double _gravity_acceleration = 1.0 / (64.0 / 7.0); bool _was_visible = false; }; -extern const std::vector< uint64_t > possibleBlocks; -extern const std::vector< uint64_t > possibleMods; -extern const std::vector< uint64_t > possibleCharacters; -extern const std::vector< LandType::Value > possibleLands; +extern const std::vector possibleBlocks; +extern const std::vector possibleMods; +extern const std::vector possibleCharacters; +extern const std::vector possibleLands; struct BlockRole { enum Value { @@ -102,18 +101,18 @@ struct BlockRole { }; }; -std::shared_ptr< MarioBlock > -createTerrainBlock( uint64_t block_id, LandType::Value type, - std::shared_ptr< SDLPP::Renderer > &renderer, - bool destructible = false, bool editor = false ); -std::shared_ptr< MarioBlock > -createTerrainBlock( uint64_t block_id, LandType::Value type, - std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y, - bool destructible = false, bool editor = false ); -std::shared_ptr< MarioBlock > -createMario( LandType::Value type, std::shared_ptr< SDLPP::Renderer > &renderer, - int x, int y, bool editor = false ); +std::shared_ptr +createTerrainBlock(uint64_t block_id, LandType::Value type, + std::shared_ptr &renderer, + bool destructible = false, bool editor = false); +std::shared_ptr +createTerrainBlock(uint64_t block_id, LandType::Value type, + std::shared_ptr &renderer, int x, int y, + bool destructible = false, bool editor = false); +std::shared_ptr +createMario(LandType::Value type, std::shared_ptr &renderer, + int x, int y, bool editor = false); -enum BlockRole::Value getBlockRole( uint64_t id ); +enum BlockRole::Value getBlockRole(uint64_t id); #endif diff --git a/mario/edit_box.cpp b/mario/edit_box.cpp index 6d7f294..25c81e4 100644 --- a/mario/edit_box.cpp +++ b/mario/edit_box.cpp @@ -3,20 +3,24 @@ #include "blocks.hpp" #include "sprites.hpp" -EditBox::EditBox(int x, int y, float start_x, float start_y, int map_width, int map_height, std::shared_ptr renderer) : SDLPP::RectangleRender(start_x + x*BLOCK_SIZE, start_y + y*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer) { +EditBox::EditBox(int x, int y, float start_x, float start_y, int map_width, + int map_height, std::shared_ptr renderer) + : SDLPP::RectangleRender(start_x + x * BLOCK_SIZE, + start_y + 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)); + addCollision(SDLPP::RectColider(0, 0, 1, 1)); } SDLPP::Vec2D EditBox::getIndexes() const { - return {_x, _y}; + return { _x, _y }; } -void EditBox::visit( SDLPP::Visitor &visitor ) { - visitor.visit( *this ); +void EditBox::visit(SDLPP::Visitor &visitor) { + visitor.visit(*this); } diff --git a/mario/edit_box.hpp b/mario/edit_box.hpp index 4560104..fe218fb 100644 --- a/mario/edit_box.hpp +++ b/mario/edit_box.hpp @@ -5,9 +5,11 @@ class EditBox : public SDLPP::RectangleRender { public: - EditBox(int x, int y, float start_x, float start_y, int map_width, int map_height, std::shared_ptr renderer); + EditBox(int x, int y, float start_x, float start_y, int map_width, + int map_height, std::shared_ptr renderer); virtual SDLPP::Vec2D getIndexes() const; - virtual void visit( SDLPP::Visitor &visitor ) override; + virtual void visit(SDLPP::Visitor &visitor) override; + private: int _x; int _y; diff --git a/mario/editor.cpp b/mario/editor.cpp index 2031a2c..1fa3b83 100644 --- a/mario/editor.cpp +++ b/mario/editor.cpp @@ -53,8 +53,8 @@ struct ToolType { struct MouseInfo { uint64_t cur_flags{}; uint64_t prev_flags{}; - SDLPP::Vec2D< int > edit_box; - SDLPP::Vec2D< int > tool_box; + SDLPP::Vec2D edit_box; + SDLPP::Vec2D tool_box; ToolType::Value tool_type{}; }; @@ -80,23 +80,23 @@ struct GlobalVars { MapInfo map{}; ToolInfo tool{}; uint64_t flags{}; - std::vector< mapColumnType > objects; - std::vector< std::shared_ptr< MarioBlock > > tools; - std::vector< std::shared_ptr< MarioBlock > > mods; - std::vector< std::shared_ptr< MarioBlock > > characters; - std::vector< std::shared_ptr< SDLPP::RenderObject > > tool_boxes; - std::vector< std::shared_ptr< SDLPP::RenderObject > > mod_boxes; - std::vector< std::shared_ptr< SDLPP::RenderObject > > character_boxes; + std::vector objects; + std::vector> tools; + std::vector> mods; + std::vector> characters; + std::vector> tool_boxes; + std::vector> mod_boxes; + std::vector> character_boxes; enum LandType::Value current_world_type{}; - std::shared_ptr< MarioBlock > coin_tool; - std::shared_ptr< MarioBlock > generic_tool; - std::shared_ptr< MarioBlock > current_tool; - std::shared_ptr< SDLPP::Texture > translucent_terrain_texture; - std::shared_ptr< SDLPP::Texture > translucent_mario_texture; - std::shared_ptr< SDLPP::Texture > translucent_mod_texture; - std::shared_ptr< SDLPP::Texture > translucent_enemies_texture; - std::shared_ptr< SDLPP::RenderObject > mario; - SDLPP::Vec2D< int > mario_pos; + std::shared_ptr coin_tool; + std::shared_ptr generic_tool; + std::shared_ptr current_tool; + std::shared_ptr translucent_terrain_texture; + std::shared_ptr translucent_mario_texture; + std::shared_ptr translucent_mod_texture; + std::shared_ptr translucent_enemies_texture; + std::shared_ptr mario; + SDLPP::Vec2D mario_pos; }; GlobalVars global_vars; @@ -105,7 +105,7 @@ std::mutex destruction_mutex; void updateTool() { auto tool_index = global_vars.tool.index; uint64_t tool_id = 0; - switch ( global_vars.tool.type ) { + switch (global_vars.tool.type) { case ToolType::BLOCK: tool_id = possibleBlocks[tool_index]; break; @@ -117,43 +117,47 @@ void updateTool() { default: break; } - auto tool_role = getBlockRole( tool_id ); - std::shared_ptr< SDLPP::Texture > target_texture = nullptr; + auto tool_role = getBlockRole(tool_id); + std::shared_ptr target_texture = nullptr; SDL_Rect target_src; - switch ( tool_role ) { + switch (tool_role) { case BlockRole::TERRAIN: target_texture = global_vars.translucent_terrain_texture; - target_src = global_vars.tools[global_vars.tool.index]->getTextureSourceRect(); + target_src = + global_vars.tools[global_vars.tool.index]->getTextureSourceRect(); break; case BlockRole::MARIO: target_texture = global_vars.translucent_mario_texture; - target_src = global_vars.characters[global_vars.tool.index]->getTextureSourceRect(); + target_src = global_vars.characters[global_vars.tool.index] + ->getTextureSourceRect(); break; case BlockRole::MODIFIER: target_texture = global_vars.translucent_mod_texture; - target_src = global_vars.mods[global_vars.tool.index]->getTextureSourceRect(); + target_src = + global_vars.mods[global_vars.tool.index]->getTextureSourceRect(); break; case BlockRole::CHARACTER: target_texture = global_vars.translucent_enemies_texture; - target_src = global_vars.characters[global_vars.tool.index]->getTextureSourceRect(); + target_src = global_vars.characters[global_vars.tool.index] + ->getTextureSourceRect(); break; } - global_vars.current_tool->setHidden( true ); - if ( tool_id == COIN_MODIFIER_ID ) { - global_vars.coin_tool->setPos( global_vars.current_tool->getPos() ); + global_vars.current_tool->setHidden(true); + if (tool_id == COIN_MODIFIER_ID) { + global_vars.coin_tool->setPos(global_vars.current_tool->getPos()); global_vars.current_tool = global_vars.coin_tool; } else { - global_vars.generic_tool->setPos( global_vars.current_tool->getPos() ); + global_vars.generic_tool->setPos(global_vars.current_tool->getPos()); global_vars.current_tool = global_vars.generic_tool; - global_vars.current_tool->setTexture( target_texture, target_src ); - global_vars.current_tool->setId( tool_id ); - global_vars.current_tool->getCollisions()[0]->setId( tool_id ); + global_vars.current_tool->setTexture(target_texture, target_src); + global_vars.current_tool->setId(tool_id); + global_vars.current_tool->getCollisions()[0]->setId(tool_id); } - global_vars.current_tool->setHidden( false ); + global_vars.current_tool->setHidden(false); } void removeMario() { - if ( !global_vars.mario ) { + if (!global_vars.mario) { return; } global_vars @@ -162,10 +166,10 @@ void removeMario() { global_vars.mario->destroy(); } -void setToolColor( const std::string &color ) { - std::vector< std::shared_ptr< SDLPP::RenderObject > > *store = nullptr; +void setToolColor(const std::string &color) { + std::vector> *store = nullptr; int multiplier = 0; - switch ( global_vars.tool.type ) { + switch (global_vars.tool.type) { case ToolType::BLOCK: multiplier = TOOLS_WIDTH; store = &global_vars.tool_boxes; @@ -180,27 +184,27 @@ void setToolColor( const std::string &color ) { default: break; } - if ( store == nullptr ) { + if (store == nullptr) { return; } - auto index = global_vars.tool.index % ( 2 * multiplier ); - store->at( index )->setColor( color ); + auto index = global_vars.tool.index % (2 * multiplier); + store->at(index)->setColor(color); } void setToolColor() { - setToolColor( "#FFFF8888" ); + setToolColor("#FFFF8888"); } void unsetToolColor() { - setToolColor( "#FFFFFF00" ); + setToolColor("#FFFFFF00"); } -void updateToolSelection( int prev_index, ToolType::Value type ) { +void updateToolSelection(int prev_index, ToolType::Value type) { unsetToolColor(); size_t cur_page = 0; size_t multiplier = 0; - std::vector< std::shared_ptr< MarioBlock > > *tool_vec = nullptr; - switch ( type ) { + std::vector> *tool_vec = nullptr; + switch (type) { case ToolType::BLOCK: cur_page = global_vars.tool.cur_page_tools; multiplier = 2 * TOOLS_WIDTH; @@ -218,68 +222,68 @@ void updateToolSelection( int prev_index, ToolType::Value type ) { default: break; } - if ( tool_vec == nullptr ) { + if (tool_vec == nullptr) { return; } auto cur = cur_page * multiplier; size_t prev = prev_index * multiplier; - for ( size_t i = prev; - i < ( tool_vec->size() < prev + multiplier ? tool_vec->size() - : prev + multiplier ); - i++ ) { - tool_vec->at( i )->setHidden( true ); + for (size_t i = prev; + i < (tool_vec->size() < prev + multiplier ? tool_vec->size() + : prev + multiplier); + i++) { + tool_vec->at(i)->setHidden(true); } - for ( size_t i = cur; - i < ( tool_vec->size() < cur + multiplier ? tool_vec->size() - : cur + multiplier ); - i++ ) { - tool_vec->at( i )->setHidden( false ); + for (size_t i = cur; + i < (tool_vec->size() < cur + multiplier ? tool_vec->size() + : cur + multiplier); + i++) { + tool_vec->at(i)->setHidden(false); } - if ( global_vars.tool.index / multiplier == cur_page ) { + if (global_vars.tool.index / multiplier == cur_page) { setToolColor(); } } -void moveToolsLeft( ToolType::Value type ) { - switch ( type ) { +void moveToolsLeft(ToolType::Value type) { + switch (type) { case ToolType::BLOCK: global_vars.tool.cur_page_tools--; - updateToolSelection( global_vars.tool.cur_page_tools + 1, type ); + updateToolSelection(global_vars.tool.cur_page_tools + 1, type); break; case ToolType::MOD: global_vars.tool.cur_page_mods--; - updateToolSelection( global_vars.tool.cur_page_mods + 1, type ); + updateToolSelection(global_vars.tool.cur_page_mods + 1, type); break; case ToolType::CHARACTER: global_vars.tool.cur_page_characters--; - updateToolSelection( global_vars.tool.cur_page_characters + 1, type ); + updateToolSelection(global_vars.tool.cur_page_characters + 1, type); default: break; } } -void moveToolsRight( ToolType::Value type ) { - switch ( type ) { +void moveToolsRight(ToolType::Value type) { + switch (type) { case ToolType::BLOCK: global_vars.tool.cur_page_tools++; - updateToolSelection( global_vars.tool.cur_page_tools - 1, type ); + updateToolSelection(global_vars.tool.cur_page_tools - 1, type); break; case ToolType::MOD: global_vars.tool.cur_page_mods++; - updateToolSelection( global_vars.tool.cur_page_mods - 1, type ); + updateToolSelection(global_vars.tool.cur_page_mods - 1, type); break; case ToolType::CHARACTER: global_vars.tool.cur_page_characters++; - updateToolSelection( global_vars.tool.cur_page_characters - 1, type ); + updateToolSelection(global_vars.tool.cur_page_characters - 1, type); default: break; } } -void updateToolIndex( uint64_t new_index, ToolType::Value new_type ) { +void updateToolIndex(uint64_t new_index, ToolType::Value new_type) { int multiplier = 0; int *page = nullptr; - switch ( new_type ) { + switch (new_type) { case ToolType::BLOCK: multiplier = 2 * TOOLS_WIDTH; page = &global_vars.tool.cur_page_tools; @@ -299,21 +303,21 @@ void updateToolIndex( uint64_t new_index, ToolType::Value new_type ) { global_vars.tool.index = new_index; setToolColor(); updateTool(); - if ( new_index / multiplier != static_cast< uint64_t >( *page ) ) { + if (new_index / multiplier != static_cast(*page)) { auto prev = *page; *page = new_index / multiplier; - updateToolSelection( prev, global_vars.tool.type ); + updateToolSelection(prev, global_vars.tool.type); } } -void updateToolIndex( uint64_t new_index ) { - updateToolIndex( new_index, global_vars.tool.type ); +void updateToolIndex(uint64_t new_index) { + updateToolIndex(new_index, global_vars.tool.type); } void selectLowerTool() { int multiplier = 0; size_t max_index = 0; - switch ( global_vars.tool.type ) { + switch (global_vars.tool.type) { case ToolType::BLOCK: multiplier = 2 * TOOLS_WIDTH; max_index = global_vars.tools.size() - 1; @@ -328,17 +332,17 @@ void selectLowerTool() { default: break; } - if ( global_vars.tool.index % multiplier >= - static_cast< uint64_t >( multiplier / 2 ) || - global_vars.tool.index + multiplier / 2 > max_index ) { + if (global_vars.tool.index % multiplier >= + static_cast(multiplier / 2) || + global_vars.tool.index + multiplier / 2 > max_index) { return; } - updateToolIndex( global_vars.tool.index + multiplier / 2 ); + updateToolIndex(global_vars.tool.index + multiplier / 2); } void selectUpperTool() { int multiplier = 0; - switch ( global_vars.tool.type ) { + switch (global_vars.tool.type) { case ToolType::BLOCK: multiplier = 2 * TOOLS_WIDTH; break; @@ -350,16 +354,16 @@ void selectUpperTool() { default: break; } - if ( global_vars.tool.index % multiplier < - static_cast< uint64_t >( multiplier / 2 ) ) { + if (global_vars.tool.index % multiplier < + static_cast(multiplier / 2)) { return; } - updateToolIndex( global_vars.tool.index - multiplier / 2 ); + updateToolIndex(global_vars.tool.index - multiplier / 2); } void selectPrevTool() { int multiplier = 0; - switch ( global_vars.tool.type ) { + switch (global_vars.tool.type) { case ToolType::BLOCK: multiplier = TOOLS_WIDTH; break; @@ -372,21 +376,20 @@ void selectPrevTool() { break; } int subtraction = 1; - if ( global_vars.tool.index % multiplier == 0 ) { + if (global_vars.tool.index % multiplier == 0) { subtraction = multiplier + 1; } - if ( global_vars.tool.index == 0 || - global_vars.tool.index - subtraction > - static_cast< uint64_t >( -multiplier ) ) { + if (global_vars.tool.index == 0 || global_vars.tool.index - subtraction > + static_cast(-multiplier)) { return; } - updateToolIndex( global_vars.tool.index - subtraction ); + updateToolIndex(global_vars.tool.index - subtraction); } void selectNextTool() { size_t max_index = 0; int multiplier = 0; - switch ( global_vars.tool.type ) { + switch (global_vars.tool.type) { case ToolType::BLOCK: max_index = global_vars.tools.size() - 1; multiplier = TOOLS_WIDTH; @@ -402,47 +405,47 @@ void selectNextTool() { break; } int addition = 1; - if ( global_vars.tool.index % multiplier == - static_cast< uint64_t >( multiplier - 1 ) ) { + if (global_vars.tool.index % multiplier == + static_cast(multiplier - 1)) { addition = multiplier + 1; } - if ( global_vars.tool.index == max_index ) { + if (global_vars.tool.index == max_index) { return; } - if ( global_vars.tool.index + addition > max_index ) { + if (global_vars.tool.index + addition > max_index) { addition = 1; } - updateToolIndex( global_vars.tool.index + addition ); + updateToolIndex(global_vars.tool.index + addition); } -void setFlag( uint64_t flag ) { +void setFlag(uint64_t flag) { global_vars.flags |= flag; } -void unsetFlag( uint64_t flag ) { +void unsetFlag(uint64_t flag) { global_vars.flags &= ~flag; } -bool getFlag( uint64_t flag ) { +bool getFlag(uint64_t flag) { return global_vars.flags & flag; } void updateWorld() { - for ( auto &block : global_vars.tools ) { - block->setType( global_vars.current_world_type ); + for (auto &block : global_vars.tools) { + block->setType(global_vars.current_world_type); } - for ( auto &block : global_vars.characters ) { - block->setType( global_vars.current_world_type ); + for (auto &block : global_vars.characters) { + block->setType(global_vars.current_world_type); } - if ( getBlockRole( global_vars.current_tool->getId() ) != - BlockRole::MODIFIER ) { - global_vars.current_tool->setType( global_vars.current_world_type ); + if (getBlockRole(global_vars.current_tool->getId()) != + BlockRole::MODIFIER) { + global_vars.current_tool->setType(global_vars.current_world_type); } } // TODO add mouse wheel control for modifiers -void handleKeyUp( SDL_Keycode key, SDLPP::Scene &scene ) { - switch ( key ) { +void handleKeyUp(SDL_Keycode key, SDLPP::Scene &scene) { + switch (key) { case SDLK_ESCAPE: - setFlag( QUIT_FLAG ); + setFlag(QUIT_FLAG); break; case SDLK_a: selectPrevTool(); @@ -474,93 +477,91 @@ void handleKeyUp( SDL_Keycode key, SDLPP::Scene &scene ) { break; case SDLK_r: scene.getRenderer().setRenderColiders( - !scene.getRenderer().getRenderColiders() ); + !scene.getRenderer().getRenderColiders()); default: break; } } -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 ); + scene.visitCollisions(*mouse, visitor); global_vars.mouse.cur_flags = visitor.getFlags(); // + 1 because the left map arrow is on position 0 global_vars.mouse.edit_box = - visitor.getEditBoxIndexes() + SDLPP::Vec2D< int >( 1, 0 ); + visitor.getEditBoxIndexes() + SDLPP::Vec2D(1, 0); global_vars.mouse.tool_box = visitor.getToolBoxIndexes(); global_vars.mouse.tool_type = - static_cast< ToolType::Value >( visitor.getToolType() ); + static_cast(visitor.getToolType()); // if we found an edit box, move tool icon to that box - if ( visitor.foundEditBox() ) { + if (visitor.foundEditBox()) { const auto &box = global_vars.mouse.edit_box; - global_vars.current_tool->setPos( box.getX() * BLOCK_SIZE, - 1 - MAP_HEIGHT * BLOCK_SIZE + - box.getY() * BLOCK_SIZE ); + global_vars.current_tool->setPos(box.getX() * BLOCK_SIZE, + 1 - MAP_HEIGHT * BLOCK_SIZE + + box.getY() * BLOCK_SIZE); } } -void mouseUpAction( uint64_t flags, SDLPP::Scene &scene ) { - if ( MouseVisitor::moveMapLeft( flags ) && global_vars.map.cur_page != 0 ) { +void mouseUpAction(uint64_t flags, SDLPP::Scene &scene) { + if (MouseVisitor::moveMapLeft(flags) && global_vars.map.cur_page != 0) { global_vars.map.cur_page--; - scene.moveEverything( BLOCK_SIZE, 0 ); + scene.moveEverything(BLOCK_SIZE, 0); } - if ( MouseVisitor::moveMapRight( flags ) ) { - if ( global_vars.map.cur_page == global_vars.map.max_page ) { + if (MouseVisitor::moveMapRight(flags)) { + if (global_vars.map.cur_page == global_vars.map.max_page) { // add column - global_vars.objects.resize( global_vars.objects.size() + 1 ); + global_vars.objects.resize(global_vars.objects.size() + 1); global_vars.map.max_page++; } global_vars.map.cur_page += 1; - scene.moveEverything( -BLOCK_SIZE, 0 ); + scene.moveEverything(-BLOCK_SIZE, 0); } - if ( MouseVisitor::moveToolsLeft( flags ) && - global_vars.tool.cur_page_tools != 0 ) { + if (MouseVisitor::moveToolsLeft(flags) && + global_vars.tool.cur_page_tools != 0) { global_vars.tool.cur_page_tools--; - updateToolSelection( global_vars.tool.cur_page_tools + 1, - ToolType::BLOCK ); + updateToolSelection(global_vars.tool.cur_page_tools + 1, + ToolType::BLOCK); } - if ( MouseVisitor::moveToolsRight( flags ) && - global_vars.tool.cur_page_tools != global_vars.tool.max_page_tools ) { + if (MouseVisitor::moveToolsRight(flags) && + global_vars.tool.cur_page_tools != global_vars.tool.max_page_tools) { global_vars.tool.cur_page_tools++; - updateToolSelection( global_vars.tool.cur_page_tools - 1, - ToolType::BLOCK ); + updateToolSelection(global_vars.tool.cur_page_tools - 1, + ToolType::BLOCK); } - if ( MouseVisitor::moveModsLeft( flags ) && - global_vars.tool.cur_page_mods != 0 ) { + if (MouseVisitor::moveModsLeft(flags) && + global_vars.tool.cur_page_mods != 0) { global_vars.tool.cur_page_mods--; - updateToolSelection( global_vars.tool.cur_page_mods + 1, - ToolType::MOD ); + updateToolSelection(global_vars.tool.cur_page_mods + 1, ToolType::MOD); } - if ( MouseVisitor::moveModsRight( flags ) && - global_vars.tool.cur_page_mods != global_vars.tool.max_page_mods ) { + if (MouseVisitor::moveModsRight(flags) && + global_vars.tool.cur_page_mods != global_vars.tool.max_page_mods) { global_vars.tool.cur_page_mods++; - updateToolSelection( global_vars.tool.cur_page_mods - 1, - ToolType::MOD ); + updateToolSelection(global_vars.tool.cur_page_mods - 1, ToolType::MOD); } - if ( MouseVisitor::moveCharactersLeft( flags ) && - global_vars.tool.cur_page_characters != 0 ) { + if (MouseVisitor::moveCharactersLeft(flags) && + global_vars.tool.cur_page_characters != 0) { global_vars.tool.cur_page_characters--; - updateToolSelection( global_vars.tool.cur_page_characters + 1, - ToolType::CHARACTER ); + updateToolSelection(global_vars.tool.cur_page_characters + 1, + ToolType::CHARACTER); } - if ( MouseVisitor::moveCharactersRight( flags ) && - global_vars.tool.cur_page_characters != - global_vars.tool.max_page_characters ) { + if (MouseVisitor::moveCharactersRight(flags) && + global_vars.tool.cur_page_characters != + global_vars.tool.max_page_characters) { global_vars.tool.cur_page_characters++; - updateToolSelection( global_vars.tool.cur_page_characters - 1, - ToolType::CHARACTER ); + updateToolSelection(global_vars.tool.cur_page_characters - 1, + ToolType::CHARACTER); } } -SDLPP::Vec2D< int > getSelectedObjectIndexes() { +SDLPP::Vec2D getSelectedObjectIndexes() { // -1 because we're indexing edit boxes from 1 (due to left arrow on map) return global_vars.mouse.edit_box + - SDLPP::Vec2D< int >( global_vars.map.cur_page - 1, 0 ); + SDLPP::Vec2D(global_vars.map.cur_page - 1, 0); } MapObject &getSelectedObject() { @@ -568,30 +569,30 @@ MapObject &getSelectedObject() { return global_vars.objects[pos.getX()][pos.getY()]; } -void placeTool( SDLPP::Scene &scene ) { - std::lock_guard< std::mutex > lock( destruction_mutex ); +void placeTool(SDLPP::Scene &scene) { + std::lock_guard lock(destruction_mutex); ToolVisitor visitor; - visitor.setSourceType( global_vars.current_world_type ); - visitor.setSourceData( global_vars.current_tool->getData() ); - auto tool_type = getBlockRole( global_vars.current_tool->getId() ); - switch ( tool_type ) { + visitor.setSourceType(global_vars.current_world_type); + visitor.setSourceData(global_vars.current_tool->getData()); + auto tool_type = getBlockRole(global_vars.current_tool->getId()); + switch (tool_type) { case BlockRole::TERRAIN: - visitor.setVisitorType( VisitorType::Terrain ); + visitor.setVisitorType(VisitorType::Terrain); break; case BlockRole::CHARACTER: case BlockRole::MARIO: - visitor.setVisitorType( VisitorType::Character ); + visitor.setVisitorType(VisitorType::Character); break; default: - visitor.setVisitorType( VisitorType::Modifier ); + visitor.setVisitorType(VisitorType::Modifier); break; } - scene.visitCollisions( *global_vars.current_tool, visitor ); + scene.visitCollisions(*global_vars.current_tool, visitor); auto &obj = getSelectedObject(); - if ( visitor.removeBlock() && !visitor.addBlock() ) { - switch ( visitor.getVisitorType() ) { + if (visitor.removeBlock() && !visitor.addBlock()) { + switch (visitor.getVisitorType()) { case VisitorType::Terrain: obj.unsetTerrain(); break; @@ -604,97 +605,97 @@ void placeTool( SDLPP::Scene &scene ) { default: break; } - } else if ( visitor.addBlock() ) { + } else if (visitor.addBlock()) { auto renderer = scene.getRendererShared(); uint64_t z_index = 1; - std::shared_ptr< MarioBlock > new_obj = nullptr; - switch ( visitor.getVisitorType() ) { + std::shared_ptr new_obj = nullptr; + switch (visitor.getVisitorType()) { case VisitorType::Terrain: - obj.setTerrain( global_vars.current_tool->getId(), - global_vars.current_world_type ); + obj.setTerrain(global_vars.current_tool->getId(), + global_vars.current_world_type); new_obj = createTerrainBlock( obj.getTerrainId(), obj.getTerrainType(), renderer, global_vars.mouse.edit_box.getX(), - global_vars.mouse.edit_box.getY(), false, true ); - new_obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID ); + global_vars.mouse.edit_box.getY(), false, true); + new_obj->getCollisions()[0]->setId(EDITOR_TERRAIN_ID); break; case VisitorType::Character: - if ( tool_type == BlockRole::MARIO ) { - obj.setCharacter( MARIO_ID, global_vars.current_world_type ); - new_obj = - createMario( global_vars.current_world_type, renderer, - global_vars.mouse.edit_box.getX(), - global_vars.mouse.edit_box.getY(), true ); + if (tool_type == BlockRole::MARIO) { + obj.setCharacter(MARIO_ID, global_vars.current_world_type); + new_obj = createMario(global_vars.current_world_type, renderer, + global_vars.mouse.edit_box.getX(), + global_vars.mouse.edit_box.getY(), true); // remove mario if exists removeMario(); global_vars.mario = new_obj; global_vars.mario_pos = getSelectedObjectIndexes(); - new_obj->getCollisions()[0]->setId( EDITOR_CHARACTER_ID ); + new_obj->getCollisions()[0]->setId(EDITOR_CHARACTER_ID); z_index = scene.getObjects().size() - 1; } else { - obj.setCharacter(global_vars.current_tool->getId(), global_vars.current_world_type); - new_obj = createTerrainBlock(obj.getCharacterId(), obj.getCharacterType(), renderer, global_vars.mouse.edit_box.getX(), global_vars.mouse.edit_box.getY(), false, true); + obj.setCharacter(global_vars.current_tool->getId(), + global_vars.current_world_type); + new_obj = createTerrainBlock( + obj.getCharacterId(), obj.getCharacterType(), renderer, + global_vars.mouse.edit_box.getX(), + global_vars.mouse.edit_box.getY(), false, true); new_obj->getCollisions()[0]->setId(EDITOR_CHARACTER_ID); - dynamic_cast< MarioBlock * >( new_obj.get() ) - ->setTerrain( false ); + dynamic_cast(new_obj.get())->setTerrain(false); z_index = scene.getObjects().size() - 1; } break; case VisitorType::Modifier: - obj.setModifier( global_vars.current_tool->getId(), - global_vars.current_tool->getData() ); + obj.setModifier(global_vars.current_tool->getId(), + global_vars.current_tool->getData()); new_obj = createTerrainBlock( obj.getModifierId(), LandType::OVERWORLD, renderer, global_vars.mouse.edit_box.getX(), - global_vars.mouse.edit_box.getY(), false, true ); - new_obj->setTextureKeepSRC( - global_vars.translucent_mod_texture ); - new_obj->setData( global_vars.current_tool->getData() ); - new_obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID ); + global_vars.mouse.edit_box.getY(), false, true); + new_obj->setTextureKeepSRC(global_vars.translucent_mod_texture); + new_obj->setData(global_vars.current_tool->getData()); + new_obj->getCollisions()[0]->setId(EDITOR_TERRAIN_ID); // TODO createModifierBlock - dynamic_cast< MarioBlock * >( new_obj.get() ) - ->setTerrain( false ); + dynamic_cast(new_obj.get())->setTerrain(false); 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); } } -void pollEvents( SDLPP::Scene &scene ) { +void pollEvents(SDLPP::Scene &scene) { SDL_Event event; - while ( SDLPP::getSDLEvent( event ) ) { - switch ( event.type ) { + while (SDLPP::getSDLEvent(event)) { + switch (event.type) { case SDL_QUIT: - setFlag( QUIT_FLAG ); + setFlag(QUIT_FLAG); break; case SDL_KEYUP: - handleKeyUp( event.key.keysym.sym, scene ); + handleKeyUp(event.key.keysym.sym, scene); break; case SDL_WINDOWEVENT: - if ( event.window.event == SDL_WINDOWEVENT_RESIZED ) { - setFlag( UPDATE_FLAG ); + if (event.window.event == SDL_WINDOWEVENT_RESIZED) { + setFlag(UPDATE_FLAG); } break; case SDL_MOUSEMOTION: - getMousePositionFlags( scene ); + getMousePositionFlags(scene); break; case SDL_MOUSEBUTTONUP: - if ( global_vars.mouse.cur_flags == global_vars.mouse.prev_flags ) { - mouseUpAction( global_vars.mouse.cur_flags, scene ); + if (global_vars.mouse.cur_flags == global_vars.mouse.prev_flags) { + mouseUpAction(global_vars.mouse.cur_flags, scene); } - if ( global_vars.mouse.edit_box.getX() != 0 ) { - placeTool( scene ); + if (global_vars.mouse.edit_box.getX() != 0) { + placeTool(scene); } - if ( global_vars.mouse.tool_box.getX() != -1 ) { + if (global_vars.mouse.tool_box.getX() != -1) { auto &tool_box = global_vars.mouse.tool_box; int multiplier = 0; size_t max_index = 0; size_t cur_page = 0; - switch ( global_vars.mouse.tool_type ) { + switch (global_vars.mouse.tool_type) { case ToolType::BLOCK: multiplier = 2 * TOOLS_WIDTH; max_index = global_vars.tools.size(); @@ -716,13 +717,13 @@ void pollEvents( SDLPP::Scene &scene ) { break; } size_t index = - tool_box.getY() * ( multiplier / 2 ) + tool_box.getX(); - if ( global_vars.mouse.tool_type == ToolType::WORLD ) { + tool_box.getY() * (multiplier / 2) + tool_box.getX(); + if (global_vars.mouse.tool_type == ToolType::WORLD) { global_vars.current_world_type = possibleLands[index]; updateWorld(); - } else if ( index < max_index ) { - updateToolIndex( cur_page * multiplier + index, - global_vars.mouse.tool_type ); + } else if (index < max_index) { + updateToolIndex(cur_page * multiplier + index, + global_vars.mouse.tool_type); } } break; @@ -731,9 +732,9 @@ void pollEvents( SDLPP::Scene &scene ) { global_vars.mouse.prev_flags = global_vars.mouse.cur_flags; break; case SDL_MOUSEWHEEL: - if ( event.wheel.y > 0 ) { + if (event.wheel.y > 0) { global_vars.current_tool->onScrollUp(); - } else if ( event.wheel.y < 0 ) { + } else if (event.wheel.y < 0) { global_vars.current_tool->onScrollDown(); } break; @@ -743,407 +744,400 @@ void pollEvents( SDLPP::Scene &scene ) { } } -void doInput( std::shared_ptr< SDLPP::Scene > scene ) { +void doInput(std::shared_ptr scene) { FPSmanager gFPS; - SDL_initFramerate( &gFPS ); - SDL_setFramerate( &gFPS, 200 ); - while ( true ) { - SDL_framerateDelay( &gFPS ); - pollEvents( *scene ); + SDL_initFramerate(&gFPS); + SDL_setFramerate(&gFPS, 200); + while (true) { + SDL_framerateDelay(&gFPS); + pollEvents(*scene); scene->updateScene(); } } -void createGrid( double start_x, double start_y, int count_x, int count_y, - std::shared_ptr< SDLPP::Scene > &scene ) { +void createGrid(double start_x, double start_y, int count_x, int count_y, + std::shared_ptr &scene) { auto renderer = scene->getRendererShared(); auto width = count_x * BLOCK_SIZE; auto height = count_y * BLOCK_SIZE; - for ( int i = 0; i < count_x + 1; i++ ) { - auto line_vertical = std::make_shared< SDLPP::LineRenderer >( + for (int i = 0; i < count_x + 1; i++) { + auto line_vertical = std::make_shared( start_x + i * BLOCK_SIZE, start_y, start_x + i * BLOCK_SIZE, - start_y + height, renderer, "#282828" ); + start_y + height, renderer, "#282828"); line_vertical->setPermanent(); - line_vertical->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); - scene->addObject( line_vertical ); + line_vertical->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); + scene->addObject(line_vertical); } - for ( int i = 0; i < count_y + 1; i++ ) { - auto line_horizontal = std::make_shared< SDLPP::LineRenderer >( + for (int i = 0; i < count_y + 1; i++) { + auto line_horizontal = std::make_shared( start_x, start_y + i * BLOCK_SIZE, start_x + width, - start_y + i * BLOCK_SIZE, renderer, "#282828" ); + start_y + i * BLOCK_SIZE, 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); } } -std::pair< std::shared_ptr< SDLPP::TextRenderer >, - std::shared_ptr< SDLPP::TextRenderer > > -createArrowControls( - double left_x, double right_x, double start_y, double height, - uint64_t left_id, uint64_t right_id, std::shared_ptr< SDLPP::Scene > &scene, - std::shared_ptr< SDLPP::FontConfiguration > &font_config ) { +std::pair, + std::shared_ptr> +createArrowControls(double left_x, double right_x, double start_y, + double height, uint64_t left_id, uint64_t right_id, + std::shared_ptr &scene, + std::shared_ptr &font_config) { auto renderer = scene->getRendererShared(); // white rectangles - auto rectangle1 = std::make_shared< SDLPP::RectangleRender >( - left_x, start_y, BLOCK_SIZE, height, renderer, "#FFFFFF88", true ); - rectangle1->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); - rectangle1->setId( left_id ); + auto rectangle1 = std::make_shared( + left_x, start_y, BLOCK_SIZE, height, renderer, "#FFFFFF88", true); + rectangle1->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); + rectangle1->setId(left_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 >( - right_x, start_y, BLOCK_SIZE, height, renderer, "#FFFFFF88", true ); - rectangle2->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); - rectangle2->setId( right_id ); + auto rectangle2 = std::make_shared( + right_x, start_y, BLOCK_SIZE, height, renderer, "#FFFFFF88", true); + rectangle2->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); + rectangle2->setId(right_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 left = std::make_shared< SDLPP::TextRenderer >( + auto left = std::make_shared( left_x, start_y + height / 2.0 - 0.5 * BLOCK_SIZE, BLOCK_SIZE, - BLOCK_SIZE, renderer, "<", font_config ); - left->setId( 0 ); - left->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); + BLOCK_SIZE, 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 >( + scene->addObject(left); + auto right = std::make_shared( right_x, start_y + height / 2.0 - 0.5 * BLOCK_SIZE, BLOCK_SIZE, - BLOCK_SIZE, renderer, ">", font_config ); - right->setId( 0 ); - right->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); + BLOCK_SIZE, renderer, ">", font_config); + right->setId(0); + right->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); right->setPermanent(); - scene->addObject( right ); + scene->addObject(right); return { left, right }; } void populateToolGrid( int count_x, int count_y, float start_x, float start_y, - ToolType::Value type, const std::vector< uint64_t > &blocks, - std::vector< std::shared_ptr< MarioBlock > > &tool_store, - std::vector< std::shared_ptr< SDLPP::RenderObject > > &tool_box_store, - std::shared_ptr< SDLPP::Scene > &scene, const std::string &title, - const std::shared_ptr< SDLPP::FontConfiguration > &font_config ) { + ToolType::Value type, const std::vector &blocks, + std::vector> &tool_store, + std::vector> &tool_box_store, + std::shared_ptr &scene, const std::string &title, + const std::shared_ptr &font_config) { auto renderer = scene->getRendererShared(); - for ( int j = 0; j < count_y; j++ ) { - for ( int i = 0; i < count_x; i++ ) { - auto tool_box = std::make_shared< ToolBox >( i, j, start_x, start_y, - renderer, false ); - scene->addObject( tool_box ); + for (int j = 0; j < count_y; j++) { + for (int i = 0; i < count_x; i++) { + auto tool_box = std::make_shared(i, j, start_x, start_y, + renderer, false); + scene->addObject(tool_box); } } int tool_index = 0; - for ( auto &block : blocks ) { - switch ( type ) { + for (auto &block : blocks) { + switch (type) { case ToolType::CHARACTER: - if ( block == MARIO_ID ) { - tool_store.push_back( createMario( - global_vars.current_world_type, renderer, 0, 0, true ) ); + if (block == MARIO_ID) { + tool_store.push_back(createMario(global_vars.current_world_type, + renderer, 0, 0, true)); break; } // fall through case ToolType::MOD: - tool_store.push_back( - createTerrainBlock( block, global_vars.current_world_type, - renderer, false, true ) ); + tool_store.push_back(createTerrainBlock( + block, global_vars.current_world_type, renderer, false, true)); break; case ToolType::BLOCK: - tool_store.push_back( - createTerrainBlock( block, global_vars.current_world_type, - renderer, false, true ) ); + tool_store.push_back(createTerrainBlock( + block, global_vars.current_world_type, renderer, false, true)); break; default: break; } - tool_store.back()->setHidden( true ); + tool_store.back()->setHidden(true); tool_store.back()->setPermanent(); tool_store.back()->pauseAnimation(); auto x = tool_index % count_x; auto y = tool_index / count_x; - tool_store.back()->setPos( start_x + x * BLOCK_SIZE, - start_y + y * BLOCK_SIZE ); - scene->addObject( tool_store.back() ); - tool_index = ( tool_index + 1 ) % ( 2 * count_x ); + tool_store.back()->setPos(start_x + x * BLOCK_SIZE, + start_y + y * BLOCK_SIZE); + scene->addObject(tool_store.back()); + tool_index = (tool_index + 1) % (2 * count_x); } - for ( int j = 0; j < count_y; j++ ) { - for ( int i = 0; i < count_x; i++ ) { + for (int j = 0; j < count_y; j++) { + for (int i = 0; i < count_x; i++) { auto tool_box = - std::make_shared< ToolBox >( i, j, start_x, start_y, renderer ); - tool_box->setType( type ); - scene->addObject( tool_box ); - tool_box->setColor( "#00000000" ); - tool_box_store.push_back( tool_box ); + std::make_shared(i, j, start_x, start_y, renderer); + tool_box->setType(type); + scene->addObject(tool_box); + tool_box->setColor("#00000000"); + tool_box_store.push_back(tool_box); } } - auto tool_text = std::make_shared< SDLPP::TextRenderer >( - start_x - BLOCK_SIZE, start_y - BLOCK_SIZE, - ( count_x + 2 ) * BLOCK_SIZE, BLOCK_SIZE, renderer, title, font_config, - SDLPP_TEXT_CENTER ); - tool_text->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); + auto tool_text = std::make_shared( + start_x - BLOCK_SIZE, start_y - BLOCK_SIZE, (count_x + 2) * BLOCK_SIZE, + BLOCK_SIZE, renderer, title, font_config, SDLPP_TEXT_CENTER); + tool_text->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); tool_text->setPermanent(); - scene->addObject( tool_text ); + scene->addObject(tool_text); } void populateWorldType( int count_x, int count_y, float start_x, float start_y, - std::shared_ptr< SDLPP::Scene > &scene, const std::string &title, - const std::shared_ptr< SDLPP::FontConfiguration > &font_config ) { + std::shared_ptr &scene, const std::string &title, + const std::shared_ptr &font_config) { auto renderer = scene->getRendererShared(); - for ( int j = 0; j < count_y; j++ ) { - for ( int i = 0; i < count_x; i++ ) { + for (int j = 0; j < count_y; j++) { + for (int i = 0; i < count_x; i++) { auto tool_box = - std::make_shared< ToolBox >( i, j, start_x, start_y, renderer ); - tool_box->setType( ToolType::WORLD ); - scene->addObject( tool_box ); + std::make_shared(i, j, start_x, start_y, renderer); + tool_box->setType(ToolType::WORLD); + scene->addObject(tool_box); } } int tool_index = 0; - for ( auto &type : possibleLands ) { - auto land = createTerrainBlock( BRICK_ID, type, renderer, false, true ); + for (auto &type : possibleLands) { + auto land = createTerrainBlock(BRICK_ID, type, renderer, false, true); auto x = tool_index % count_x; auto y = tool_index / count_x; - land->setId( EDITOR_WORLD_CHANGE_ID ); + land->setId(EDITOR_WORLD_CHANGE_ID); land->setPermanent(); - land->setPos( start_x + x * BLOCK_SIZE, start_y + y * BLOCK_SIZE ); - scene->addObject( land ); - tool_index = ( tool_index + 1 ) % ( 2 * count_x ); + land->setPos(start_x + x * BLOCK_SIZE, start_y + y * BLOCK_SIZE); + scene->addObject(land); + tool_index = (tool_index + 1) % (2 * count_x); } - auto tool_text = std::make_shared< SDLPP::TextRenderer >( + auto tool_text = std::make_shared( start_x, start_y - BLOCK_SIZE, count_x * BLOCK_SIZE, BLOCK_SIZE, - renderer, title, font_config, SDLPP_TEXT_CENTER ); - tool_text->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); + renderer, title, font_config, SDLPP_TEXT_CENTER); + tool_text->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); tool_text->setPermanent(); - scene->addObject( tool_text ); + scene->addObject(tool_text); } -void checkArrowsEnabled( uint64_t cur_page, uint64_t max_page, - uint64_t left_flag, uint64_t right_flag, - std::shared_ptr< SDLPP::TextRenderer > &left_arrow, - std::shared_ptr< SDLPP::TextRenderer > &right_arrow, - std::shared_ptr< SDLPP::Font > &font, - bool map = false ) { - if ( cur_page == 0 && getFlag( left_flag ) ) { - setFlag( UPDATE_FLAG ); - unsetFlag( left_flag ); - left_arrow->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 ); - } else if ( cur_page != 0 && !getFlag( left_flag ) ) { - setFlag( UPDATE_FLAG ); - setFlag( left_flag ); - left_arrow->setTextColor( font, "#000000", "#282828", 0.05 ); +void checkArrowsEnabled(uint64_t cur_page, uint64_t max_page, + uint64_t left_flag, uint64_t right_flag, + std::shared_ptr &left_arrow, + std::shared_ptr &right_arrow, + std::shared_ptr &font, bool map = false) { + if (cur_page == 0 && getFlag(left_flag)) { + setFlag(UPDATE_FLAG); + unsetFlag(left_flag); + left_arrow->setTextColor(font, "#CCCCCC", "#CCCCCC", 0.05); + } else if (cur_page != 0 && !getFlag(left_flag)) { + setFlag(UPDATE_FLAG); + setFlag(left_flag); + left_arrow->setTextColor(font, "#000000", "#282828", 0.05); } - if ( cur_page == max_page && getFlag( right_flag ) ) { - setFlag( UPDATE_FLAG ); - unsetFlag( right_flag ); - if ( map ) { - right_arrow->setTextColor( font, "#00FF00", "#000000", 0.1 ); - right_arrow->changeText( "+" ); + if (cur_page == max_page && getFlag(right_flag)) { + setFlag(UPDATE_FLAG); + unsetFlag(right_flag); + if (map) { + right_arrow->setTextColor(font, "#00FF00", "#000000", 0.1); + right_arrow->changeText("+"); } else { - right_arrow->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 ); + right_arrow->setTextColor(font, "#CCCCCC", "#CCCCCC", 0.05); } - } else if ( cur_page != max_page && !getFlag( right_flag ) ) { - setFlag( UPDATE_FLAG ); - setFlag( right_flag ); - right_arrow->setTextColor( font, "#000000", "#282828", 0.05 ); - if ( map ) { - right_arrow->changeText( ">" ); + } else if (cur_page != max_page && !getFlag(right_flag)) { + setFlag(UPDATE_FLAG); + setFlag(right_flag); + right_arrow->setTextColor(font, "#000000", "#282828", 0.05); + if (map) { + right_arrow->changeText(">"); } } } #ifdef _WIN32 -int WINAPI wWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, - PWSTR szCmdLine, int nCmdShow ) { +int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, + PWSTR szCmdLine, int nCmdShow) { #else int main() { #endif SDLPP::init(); - SDLPP::Window w( "Mario editor!" ); - w.setResizable( true ); + SDLPP::Window w("Mario editor!"); + w.setResizable(true); BLOCK_SIZE = 1.0 / 26; - auto font = std::make_shared< SDLPP::Font >( "testfont.ttf", 36 ); - auto font_config = std::make_shared< SDLPP::FontConfiguration >( - font, "#000000", "#282828", 0.05 ); - g_text_config = std::make_shared< SDLPP::FontConfiguration >( - font, "#FFFFFF", "#000000", 0.15 ); + auto font = std::make_shared("testfont.ttf", 36); + auto font_config = std::make_shared( + font, "#000000", "#282828", 0.05); + g_text_config = std::make_shared(font, "#FFFFFF", + "#000000", 0.15); - auto renderer = std::make_shared< SDLPP::Renderer >( w ); - renderer->setBlendMode( SDL_BLENDMODE_BLEND ); + auto renderer = std::make_shared(w); + renderer->setBlendMode(SDL_BLENDMODE_BLEND); // prepare global vars - g_terrain_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); - g_mario_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); + g_terrain_texture = std::make_shared( + renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY); + g_mario_texture = std::make_shared( + renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY); g_mod_texture = - std::make_shared< SDLPP::Texture >( renderer, "sprites/mods.png" ); - g_enemies_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/enemies.png", MARIO_OVERWORLD_COLORKEY ); - g_translucent_terrain_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); - g_translucent_terrain_texture->setAlpha( 100 ); + std::make_shared(renderer, "sprites/mods.png"); + g_enemies_texture = std::make_shared( + renderer, "sprites/enemies.png", MARIO_OVERWORLD_COLORKEY); + g_translucent_terrain_texture = std::make_shared( + renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY); + g_translucent_terrain_texture->setAlpha(100); g_translucent_mod_texture = - std::make_shared< SDLPP::Texture >( renderer, "sprites/mods.png" ); - g_translucent_mod_texture->setAlpha( 100 ); - g_translucent_enemies_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/enemies.png", MARIO_OVERWORLD_COLORKEY ); - g_translucent_enemies_texture->setAlpha( 100 ); + std::make_shared(renderer, "sprites/mods.png"); + g_translucent_mod_texture->setAlpha(100); + g_translucent_enemies_texture = std::make_shared( + renderer, "sprites/enemies.png", MARIO_OVERWORLD_COLORKEY); + g_translucent_enemies_texture->setAlpha(100); - auto scene = std::make_shared< SDLPP::Scene >( renderer ); - auto bg = std::make_shared< SDLPP::RectangleRender >( - 0, 0, 10, 10, renderer, MARIO_OVERWORLD_COLORKEY, true ); + auto scene = std::make_shared(renderer); + auto bg = std::make_shared( + 0, 0, 10, 10, renderer, MARIO_OVERWORLD_COLORKEY, true); bg->setPermanent(); - bg->setId( 1 ); - scene->addObject( bg ); + bg->setId(1); + scene->addObject(bg); global_vars.current_world_type = LandType::OVERWORLD; // TODO file name - loadMap( scene, global_vars.mario, "test_binary.bin", global_vars.objects, - true, MAP_WIDTH ); + loadMap(scene, global_vars.mario, "test_binary.bin", global_vars.objects, + true, MAP_WIDTH); // create grids and arrow controls // map auto arrows = createArrowControls( - 0, ( MAP_WIDTH + 1 ) * BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, + 0, (MAP_WIDTH + 1) * BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE, EDITOR_LEFT_MAP_ID, EDITOR_RIGHT_MAP_ID, scene, - font_config ); + font_config); auto left_map_arrow = arrows.first; auto right_map_arrow = arrows.second; - createGrid( BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, MAP_WIDTH, MAP_HEIGHT, - scene ); + createGrid(BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, MAP_WIDTH, MAP_HEIGHT, + scene); // edit blocks on map - for ( int i = 0; i < MAP_WIDTH; i++ ) { - for ( int j = 0; j < MAP_HEIGHT; j++ ) { - scene->addObject( std::make_shared< EditBox >( + for (int i = 0; i < MAP_WIDTH; i++) { + for (int j = 0; j < MAP_HEIGHT; j++) { + scene->addObject(std::make_shared( i, j, BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, MAP_WIDTH, - MAP_HEIGHT, renderer ) ); + MAP_HEIGHT, renderer)); } } // tools - populateToolGrid( TOOLS_WIDTH, 2, ( MAP_WIDTH - TOOLS_WIDTH ) * BLOCK_SIZE, - 1 - ( MAP_HEIGHT + 3 ) * BLOCK_SIZE, ToolType::BLOCK, - possibleBlocks, global_vars.tools, global_vars.tool_boxes, - scene, "TERRAIN", font_config ); + populateToolGrid(TOOLS_WIDTH, 2, (MAP_WIDTH - TOOLS_WIDTH) * BLOCK_SIZE, + 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, ToolType::BLOCK, + possibleBlocks, global_vars.tools, global_vars.tool_boxes, + scene, "TERRAIN", font_config); arrows = createArrowControls( - ( MAP_WIDTH - TOOLS_WIDTH - 1 ) * BLOCK_SIZE, MAP_WIDTH * BLOCK_SIZE, - 1 - ( MAP_HEIGHT + 3 ) * BLOCK_SIZE, 2 * BLOCK_SIZE, - EDITOR_LEFT_TOOL_ID, EDITOR_RIGHT_TOOL_ID, scene, font_config ); + (MAP_WIDTH - TOOLS_WIDTH - 1) * BLOCK_SIZE, MAP_WIDTH * BLOCK_SIZE, + 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, 2 * BLOCK_SIZE, EDITOR_LEFT_TOOL_ID, + EDITOR_RIGHT_TOOL_ID, scene, font_config); auto left_tool_arrow = arrows.first; auto right_tool_arrow = arrows.second; - createGrid( ( MAP_WIDTH - TOOLS_WIDTH ) * BLOCK_SIZE, - 1 - ( MAP_HEIGHT + 3 ) * BLOCK_SIZE, TOOLS_WIDTH, 2, scene ); + createGrid((MAP_WIDTH - TOOLS_WIDTH) * BLOCK_SIZE, + 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, TOOLS_WIDTH, 2, scene); // mods - populateToolGrid( MOD_WIDTH, 2, 5 * BLOCK_SIZE, - 1 - ( MAP_HEIGHT + 3 ) * BLOCK_SIZE, ToolType::MOD, - possibleMods, global_vars.mods, global_vars.mod_boxes, - scene, "MODS", font_config ); - arrows = createArrowControls( - 4 * BLOCK_SIZE, ( MOD_WIDTH + 5 ) * BLOCK_SIZE, - 1 - ( MAP_HEIGHT + 3 ) * BLOCK_SIZE, 2 * BLOCK_SIZE, EDITOR_LEFT_MOD_ID, - EDITOR_RIGHT_MOD_ID, scene, font_config ); + populateToolGrid(MOD_WIDTH, 2, 5 * BLOCK_SIZE, + 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, ToolType::MOD, + possibleMods, global_vars.mods, global_vars.mod_boxes, + scene, "MODS", font_config); + arrows = createArrowControls(4 * BLOCK_SIZE, (MOD_WIDTH + 5) * BLOCK_SIZE, + 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, + 2 * BLOCK_SIZE, EDITOR_LEFT_MOD_ID, + EDITOR_RIGHT_MOD_ID, scene, font_config); auto left_mod_arrow = arrows.first; auto right_mod_arrow = arrows.second; - createGrid( 5 * BLOCK_SIZE, 1 - ( MAP_HEIGHT + 3 ) * BLOCK_SIZE, MOD_WIDTH, - 2, scene ); + createGrid(5 * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, MOD_WIDTH, 2, + scene); // characters - populateToolGrid( CHARACTER_WIDTH, 2, ( MOD_WIDTH + 8 ) * BLOCK_SIZE, - 1 - ( MAP_HEIGHT + 3 ) * BLOCK_SIZE, ToolType::CHARACTER, - possibleCharacters, global_vars.characters, - global_vars.character_boxes, scene, "CHARACTERS", - font_config ); - arrows = - createArrowControls( ( MOD_WIDTH + 7 ) * BLOCK_SIZE, - ( MOD_WIDTH + 8 + CHARACTER_WIDTH ) * BLOCK_SIZE, - 1 - ( MAP_HEIGHT + 3 ) * BLOCK_SIZE, - 2 * BLOCK_SIZE, EDITOR_LEFT_CHARACTER_ID, - EDITOR_RIGHT_CHARACTER_ID, scene, font_config ); + populateToolGrid(CHARACTER_WIDTH, 2, (MOD_WIDTH + 8) * BLOCK_SIZE, + 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, ToolType::CHARACTER, + possibleCharacters, global_vars.characters, + global_vars.character_boxes, scene, "CHARACTERS", + font_config); + arrows = createArrowControls((MOD_WIDTH + 7) * BLOCK_SIZE, + (MOD_WIDTH + 8 + CHARACTER_WIDTH) * BLOCK_SIZE, + 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, + 2 * BLOCK_SIZE, EDITOR_LEFT_CHARACTER_ID, + EDITOR_RIGHT_CHARACTER_ID, scene, font_config); auto left_char_arrow = arrows.first; auto right_char_arrow = arrows.second; - createGrid( ( MOD_WIDTH + 8 ) * BLOCK_SIZE, - 1 - ( MAP_HEIGHT + 3 ) * BLOCK_SIZE, CHARACTER_WIDTH, 2, - scene ); + createGrid((MOD_WIDTH + 8) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, + CHARACTER_WIDTH, 2, scene); // world type - populateWorldType( OVERWORLD_WIDTH, 2, BLOCK_SIZE, - 1 - ( MAP_HEIGHT + 3 ) * BLOCK_SIZE, scene, "WORLD", - font_config ); - createGrid( BLOCK_SIZE, 1 - ( MAP_HEIGHT + 3 ) * BLOCK_SIZE, - OVERWORLD_WIDTH, 2, scene ); + populateWorldType(OVERWORLD_WIDTH, 2, BLOCK_SIZE, + 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, scene, "WORLD", + font_config); + createGrid(BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, OVERWORLD_WIDTH, + 2, scene); global_vars.map.max_page = global_vars.objects.size() - MAP_WIDTH; global_vars.tool.max_page_tools = - ( possibleBlocks.size() - 1 ) / ( 2 * TOOLS_WIDTH ); + (possibleBlocks.size() - 1) / (2 * TOOLS_WIDTH); global_vars.tool.max_page_mods = - ( possibleMods.size() - 1 ) / ( 2 * MOD_WIDTH ); + (possibleMods.size() - 1) / (2 * MOD_WIDTH); global_vars.tool.max_page_characters = - ( possibleCharacters.size() - 1 ) / ( 2 * CHARACTER_WIDTH ); + (possibleCharacters.size() - 1) / (2 * CHARACTER_WIDTH); - auto mouse = 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( EDITOR_MOUSE_ID ); - mouse->setColiderColor( "#00FF00" ); - mouse->addCollision( SDLPP::RectColider( { 0, 0 }, { 1, 1 } ) ); - scene->addObject( mouse ); + auto mouse = + std::make_shared(0.01, 0.01, 0, 0, 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 })); + scene->addObject(mouse); global_vars.translucent_terrain_texture = g_translucent_terrain_texture; - global_vars.translucent_mario_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); - global_vars.translucent_mario_texture->setAlpha( 100 ); + global_vars.translucent_mario_texture = std::make_shared( + renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY); + global_vars.translucent_mario_texture->setAlpha(100); global_vars.generic_tool = - createTerrainBlock( possibleBlocks[global_vars.tool.index], - global_vars.current_world_type, renderer, false ); + createTerrainBlock(possibleBlocks[global_vars.tool.index], + global_vars.current_world_type, renderer, false); global_vars.generic_tool->setTextureKeepSRC( - global_vars.translucent_terrain_texture ); + global_vars.translucent_terrain_texture); global_vars.generic_tool->removeCollisions(); global_vars.generic_tool->addCollision( - SDLPP::RectColider( 0.1, 0.1, 0.8, 0.8 ) ); + SDLPP::RectColider(0.1, 0.1, 0.8, 0.8)); global_vars.current_tool = global_vars.generic_tool; global_vars.coin_tool = createTerrainBlock( - COIN_MODIFIER_ID, LandType::OVERWORLD, renderer, 0, 0, false, true ); - global_vars.coin_tool->setData( 1 ); + COIN_MODIFIER_ID, LandType::OVERWORLD, renderer, 0, 0, false, true); + global_vars.coin_tool->setData(1); global_vars.coin_tool->removeCollisions(); - global_vars.coin_tool->addCollision( - SDLPP::RectColider( 0.1, 0.1, 0.8, 0.8 ) ); + global_vars.coin_tool->addCollision(SDLPP::RectColider(0.1, 0.1, 0.8, 0.8)); global_vars.translucent_mod_texture = g_translucent_mod_texture; global_vars.translucent_enemies_texture = g_translucent_enemies_texture; - dynamic_cast< MarioBlock & >( *global_vars.current_tool ).setTool(); - scene->addObject( global_vars.current_tool ); - scene->addObject( global_vars.coin_tool ); - global_vars.coin_tool->setHidden( true ); - scene->moveZTop( global_vars.current_tool ); - scene->moveZTop( global_vars.coin_tool ); + dynamic_cast(*global_vars.current_tool).setTool(); + scene->addObject(global_vars.current_tool); + scene->addObject(global_vars.coin_tool); + global_vars.coin_tool->setHidden(true); + scene->moveZTop(global_vars.current_tool); + scene->moveZTop(global_vars.coin_tool); - scene->moveEverything( BLOCK_SIZE, 0 ); + scene->moveEverything(BLOCK_SIZE, 0); FPSmanager gFPS; - SDL_initFramerate( &gFPS ); - SDL_setFramerate( &gFPS, 60 ); + SDL_initFramerate(&gFPS); + SDL_setFramerate(&gFPS, 60); - updateToolSelection( 0, ToolType::BLOCK ); - updateToolSelection( 0, ToolType::MOD ); - updateToolSelection( 0, ToolType::CHARACTER ); + updateToolSelection(0, ToolType::BLOCK); + updateToolSelection(0, ToolType::MOD); + updateToolSelection(0, ToolType::CHARACTER); setToolColor(); auto base = SDL_GetTicks(); int frames = 0; - std::thread inputThread( doInput, scene ); + std::thread inputThread(doInput, scene); inputThread.detach(); - setFlag( UPDATE_FLAG ); + setFlag(UPDATE_FLAG); global_vars.tool.cur_page_tools = 0; global_vars.tool.cur_page_mods = 0; global_vars.tool.cur_page_characters = 0; // required for initial correct rendering - setFlag( MAP_LEFT_ENABLED_FLAG | MAP_RIGHT_ENABLED_FLAG | - TOOL_LEFT_ENABLED_FLAG | TOOL_RIGHT_ENABLED_FLAG | - MOD_LEFT_ENABLED_FLAG | MOD_RIGHT_ENABLED_FLAG | - CHARACTER_LEFT_ENABLED_FLAG | CHARACTER_RIGHT_ENABLED_FLAG ); + setFlag(MAP_LEFT_ENABLED_FLAG | MAP_RIGHT_ENABLED_FLAG | + TOOL_LEFT_ENABLED_FLAG | TOOL_RIGHT_ENABLED_FLAG | + MOD_LEFT_ENABLED_FLAG | MOD_RIGHT_ENABLED_FLAG | + CHARACTER_LEFT_ENABLED_FLAG | CHARACTER_RIGHT_ENABLED_FLAG); SDL_PumpEvents(); scene->updateSizeAndPosition(); @@ -1151,40 +1145,40 @@ int main() { renderer->presentRenderer(); setFlag(UPDATE_FLAG); - while ( !getFlag( QUIT_FLAG ) ) { - SDL_framerateDelay( &gFPS ); + while (!getFlag(QUIT_FLAG)) { + SDL_framerateDelay(&gFPS); SDL_PumpEvents(); - std::lock_guard< std::mutex > lock( destruction_mutex ); + std::lock_guard lock(destruction_mutex); scene->renderScene(); renderer->presentRenderer(); frames++; - if ( SDL_GetTicks() - base >= 1000 ) { + if (SDL_GetTicks() - base >= 1000) { std::cout << "FPS: " << frames << std::endl; frames = 0; base = SDL_GetTicks(); } - checkArrowsEnabled( global_vars.map.cur_page, global_vars.map.max_page, - MAP_LEFT_ENABLED_FLAG, MAP_RIGHT_ENABLED_FLAG, - left_map_arrow, right_map_arrow, font, true ); - checkArrowsEnabled( global_vars.tool.cur_page_tools, - global_vars.tool.max_page_tools, - TOOL_LEFT_ENABLED_FLAG, TOOL_RIGHT_ENABLED_FLAG, - left_tool_arrow, right_tool_arrow, font ); - checkArrowsEnabled( global_vars.tool.cur_page_mods, - global_vars.tool.max_page_mods, - MOD_LEFT_ENABLED_FLAG, MOD_RIGHT_ENABLED_FLAG, - left_mod_arrow, right_mod_arrow, font ); - checkArrowsEnabled( global_vars.tool.cur_page_characters, - global_vars.tool.max_page_characters, - CHARACTER_LEFT_ENABLED_FLAG, - CHARACTER_RIGHT_ENABLED_FLAG, left_char_arrow, - right_char_arrow, font ); - if ( getFlag( UPDATE_FLAG ) ) { + checkArrowsEnabled(global_vars.map.cur_page, global_vars.map.max_page, + MAP_LEFT_ENABLED_FLAG, MAP_RIGHT_ENABLED_FLAG, + left_map_arrow, right_map_arrow, font, true); + checkArrowsEnabled(global_vars.tool.cur_page_tools, + global_vars.tool.max_page_tools, + TOOL_LEFT_ENABLED_FLAG, TOOL_RIGHT_ENABLED_FLAG, + left_tool_arrow, right_tool_arrow, font); + checkArrowsEnabled(global_vars.tool.cur_page_mods, + global_vars.tool.max_page_mods, + MOD_LEFT_ENABLED_FLAG, MOD_RIGHT_ENABLED_FLAG, + left_mod_arrow, right_mod_arrow, font); + checkArrowsEnabled(global_vars.tool.cur_page_characters, + global_vars.tool.max_page_characters, + CHARACTER_LEFT_ENABLED_FLAG, + CHARACTER_RIGHT_ENABLED_FLAG, left_char_arrow, + right_char_arrow, font); + if (getFlag(UPDATE_FLAG)) { scene->updateSizeAndPosition(); - unsetFlag( UPDATE_FLAG ); + unsetFlag(UPDATE_FLAG); } } - saveMap( "test_binary2.bin", global_vars.objects ); + saveMap("test_binary2.bin", global_vars.objects); return 0; } diff --git a/mario/editor_visitor.cpp b/mario/editor_visitor.cpp index 6a280fe..ab4e1f4 100644 --- a/mario/editor_visitor.cpp +++ b/mario/editor_visitor.cpp @@ -16,9 +16,9 @@ #define SELECTED_RIGHT_CHARACTER 0x00000100 #define SELECTED_LEFT_CHARACTER 0x00000200 -void MouseVisitor::visit( const SDLPP::RenderObject &obj ) { +void MouseVisitor::visit(const SDLPP::RenderObject &obj) { auto id = obj.getId(); - switch ( id ) { + switch (id) { case EDITOR_LEFT_MAP_ID: select_flags |= SELECTED_LEFT_MAP; break; @@ -45,72 +45,72 @@ void MouseVisitor::visit( const SDLPP::RenderObject &obj ) { break; case EDITOR_EDIT_SQUARE: edit_box = true; - edit_box_location = dynamic_cast< const EditBox & >( obj ).getIndexes(); + edit_box_location = dynamic_cast(obj).getIndexes(); break; case EDITOR_TOOL_ID: tool_box = true; - tool_box_location = dynamic_cast< const ToolBox & >( obj ).getIndexes(); - tool_box_type = dynamic_cast< const ToolBox & >( obj ).getType(); + tool_box_location = dynamic_cast(obj).getIndexes(); + tool_box_type = dynamic_cast(obj).getType(); break; default: break; } } -bool MouseVisitor::moveMapLeft( uint64_t flags ) { +bool MouseVisitor::moveMapLeft(uint64_t flags) { return flags & SELECTED_LEFT_MAP; } -bool MouseVisitor::moveMapRight( uint64_t flags ) { +bool MouseVisitor::moveMapRight(uint64_t flags) { return flags & SELECTED_RIGHT_MAP; } -bool MouseVisitor::moveToolsLeft( uint64_t flags ) { +bool MouseVisitor::moveToolsLeft(uint64_t flags) { return flags & SELECTED_LEFT_TOOL; } -bool MouseVisitor::moveToolsRight( uint64_t flags ) { +bool MouseVisitor::moveToolsRight(uint64_t flags) { return flags & SELECTED_RIGHT_TOOL; } -bool MouseVisitor::moveModsLeft( uint64_t flags ) { +bool MouseVisitor::moveModsLeft(uint64_t flags) { return flags & SELECTED_LEFT_MOD; } -bool MouseVisitor::moveModsRight( uint64_t flags ) { +bool MouseVisitor::moveModsRight(uint64_t flags) { return flags & SELECTED_RIGHT_MOD; } -bool MouseVisitor::moveCharactersLeft( uint64_t flags ) { +bool MouseVisitor::moveCharactersLeft(uint64_t flags) { return flags & SELECTED_LEFT_CHARACTER; } -bool MouseVisitor::moveCharactersRight( uint64_t flags ) { +bool MouseVisitor::moveCharactersRight(uint64_t flags) { return flags & SELECTED_RIGHT_CHARACTER; } -void ToolVisitor::visit( const SDLPP::RenderObject &obj ) { +void ToolVisitor::visit(const SDLPP::RenderObject &obj) { auto id = obj.getCollisions()[0]->getId(); - switch ( id ) { + switch (id) { case EDITOR_TERRAIN_ID: { - const auto &m_obj = dynamic_cast(obj); + const auto &m_obj = dynamic_cast(obj); remove_block = true; - if ( obj.getId() == source_id && - ((m_obj.getType() == source_type && - getVisitorType() == VisitorType::Terrain) || ( m_obj.getData() == _data && getVisitorType() == VisitorType::Modifier))) { + if (obj.getId() == source_id && + ((m_obj.getType() == source_type && + getVisitorType() == VisitorType::Terrain) || + (m_obj.getData() == _data && + getVisitorType() == VisitorType::Modifier))) { add_block = false; } - } - break; + } break; case EDITOR_CHARACTER_ID: { - const auto &m_obj = dynamic_cast(obj); + const auto &m_obj = dynamic_cast(obj); remove_block = true; - if ( obj.getId() == source_id && - m_obj.getType() == source_type && - getVisitorType() == VisitorType::Character ) { + if (obj.getId() == source_id && m_obj.getType() == source_type && + getVisitorType() == VisitorType::Character) { add_block = false; } - } + } default: break; } diff --git a/mario/editor_visitor.hpp b/mario/editor_visitor.hpp index 2d2aaea..f4b2a90 100644 --- a/mario/editor_visitor.hpp +++ b/mario/editor_visitor.hpp @@ -17,8 +17,8 @@ struct VisitorType { class MouseVisitor : public SDLPP::Visitor { public: MouseVisitor() = default; - void visit( const SDLPP::RenderObject &obj ) override; - void setFromId( uint64_t /*UNUSED*/ ) override {} + void visit(const SDLPP::RenderObject &obj) override; + void setFromId(uint64_t /*UNUSED*/) override {} uint64_t getFromId() const override { return 0; } @@ -28,16 +28,16 @@ public: bool foundEditBox() const { return edit_box; } - const SDLPP::Vec2D< int > &getEditBoxIndexes() const { + const SDLPP::Vec2D &getEditBoxIndexes() const { return edit_box_location; } bool foundToolBox() const { return tool_box; } - const SDLPP::Vec2D< int > &getToolBoxIndexes() const { + const SDLPP::Vec2D &getToolBoxIndexes() const { return tool_box_location; } - void setVisitorType( uint64_t type ) override { + void setVisitorType(uint64_t type) override { _type = type; } uint64_t getVisitorType() const override { @@ -47,21 +47,21 @@ public: return tool_box_type; } - static bool moveMapLeft( uint64_t flags ); - static bool moveMapRight( uint64_t flags ); - static bool moveToolsLeft( uint64_t flags ); - static bool moveToolsRight( uint64_t flags ); - static bool moveModsLeft( uint64_t flags ); - static bool moveModsRight( uint64_t flags ); - static bool moveCharactersLeft( uint64_t flags ); - static bool moveCharactersRight( uint64_t flags ); + static bool moveMapLeft(uint64_t flags); + static bool moveMapRight(uint64_t flags); + static bool moveToolsLeft(uint64_t flags); + static bool moveToolsRight(uint64_t flags); + static bool moveModsLeft(uint64_t flags); + static bool moveModsRight(uint64_t flags); + static bool moveCharactersLeft(uint64_t flags); + static bool moveCharactersRight(uint64_t flags); private: uint64_t select_flags = 0; bool edit_box = false; bool tool_box = false; - SDLPP::Vec2D< int > edit_box_location = { -1, -1 }; - SDLPP::Vec2D< int > tool_box_location = { -1, -1 }; + SDLPP::Vec2D edit_box_location = { -1, -1 }; + SDLPP::Vec2D tool_box_location = { -1, -1 }; uint64_t _type{}; uint64_t tool_box_type = 0; }; @@ -69,14 +69,14 @@ private: class ToolVisitor : public SDLPP::Visitor { public: ToolVisitor() = default; - void visit( const SDLPP::RenderObject &obj ) override; - void setFromId( uint64_t id ) override { + void visit(const SDLPP::RenderObject &obj) override; + void setFromId(uint64_t id) override { source_id = id; } uint64_t getFromId() const override { return source_id; } - void setVisitorType( uint64_t type ) override { + void setVisitorType(uint64_t type) override { _type = type; } uint64_t getVisitorType() const override { diff --git a/mario/global_vars.cpp b/mario/global_vars.cpp index 310fcae..9bd67f7 100644 --- a/mario/global_vars.cpp +++ b/mario/global_vars.cpp @@ -1,12 +1,12 @@ #include "global_vars.hpp" #include "../sdlpp/sdlpp_texture.hpp" -std::shared_ptr< SDLPP::Texture > g_terrain_texture{}; -std::shared_ptr< SDLPP::Texture > g_mario_texture{}; -std::shared_ptr< SDLPP::Texture > g_mod_texture{}; -std::shared_ptr< SDLPP::Texture > g_enemies_texture{}; -std::shared_ptr< SDLPP::Texture > g_translucent_terrain_texture{}; -std::shared_ptr< SDLPP::Texture > g_translucent_mod_texture{}; -std::shared_ptr< SDLPP::Texture > g_translucent_enemies_texture; -std::shared_ptr< SDLPP::Scene > g_playground{}; -std::shared_ptr< SDLPP::FontConfiguration > g_text_config{}; +std::shared_ptr g_terrain_texture{}; +std::shared_ptr g_mario_texture{}; +std::shared_ptr g_mod_texture{}; +std::shared_ptr g_enemies_texture{}; +std::shared_ptr g_translucent_terrain_texture{}; +std::shared_ptr g_translucent_mod_texture{}; +std::shared_ptr g_translucent_enemies_texture; +std::shared_ptr g_playground{}; +std::shared_ptr g_text_config{}; diff --git a/mario/global_vars.hpp b/mario/global_vars.hpp index c56ae4b..45e5fa4 100644 --- a/mario/global_vars.hpp +++ b/mario/global_vars.hpp @@ -3,14 +3,14 @@ #include "../sdlpp/sdlpp.hpp" -extern std::shared_ptr< SDLPP::Texture > g_terrain_texture; -extern std::shared_ptr< SDLPP::Texture > g_mario_texture; -extern std::shared_ptr< SDLPP::Texture > g_mod_texture; -extern std::shared_ptr< SDLPP::Texture > g_enemies_texture; -extern std::shared_ptr< SDLPP::Texture > g_translucent_terrain_texture; -extern std::shared_ptr< SDLPP::Texture > g_translucent_mod_texture; -extern std::shared_ptr< SDLPP::Texture > g_translucent_enemies_texture; -extern std::shared_ptr< SDLPP::Scene > g_playground; -extern std::shared_ptr< SDLPP::FontConfiguration > g_text_config; +extern std::shared_ptr g_terrain_texture; +extern std::shared_ptr g_mario_texture; +extern std::shared_ptr g_mod_texture; +extern std::shared_ptr g_enemies_texture; +extern std::shared_ptr g_translucent_terrain_texture; +extern std::shared_ptr g_translucent_mod_texture; +extern std::shared_ptr g_translucent_enemies_texture; +extern std::shared_ptr g_playground; +extern std::shared_ptr g_text_config; #endif diff --git a/mario/main.cpp b/mario/main.cpp index c55fc4a..c1873bd 100644 --- a/mario/main.cpp +++ b/mario/main.cpp @@ -22,20 +22,20 @@ bool quit = false; bool update = false; -std::shared_ptr< Mario > mario = nullptr; -std::shared_ptr< SDLPP::RectangleRender > leftStop = nullptr; -std::shared_ptr< SDLPP::Renderer > renderer = nullptr; -std::shared_ptr< SDLPP::TextRenderer > fps = nullptr; -std::shared_ptr< SDLPP::TextRenderer > coins = nullptr; +std::shared_ptr mario = nullptr; +std::shared_ptr leftStop = nullptr; +std::shared_ptr renderer = nullptr; +std::shared_ptr fps = nullptr; +std::shared_ptr coins = nullptr; int coin_count = 0; int global_frames = 0; -std::vector< std::shared_ptr< MarioBlock > > moving_objects = {}; +std::vector> moving_objects = {}; std::mutex render_mutex; -void handleKeyDown( SDL_Keycode key, SDLPP::Scene &scene ) { - switch ( key ) { +void handleKeyDown(SDL_Keycode key, SDLPP::Scene &scene) { + switch (key) { case SDLK_ESCAPE: quit = true; break; @@ -53,19 +53,19 @@ void handleKeyDown( SDL_Keycode key, SDLPP::Scene &scene ) { break; case SDLK_r: scene.getRenderer().setRenderColiders( - !scene.getRenderer().getRenderColiders() ); + !scene.getRenderer().getRenderColiders()); break; case SDLK_f: - if ( fps ) { - fps->setHidden( !fps->getHidden() ); + if (fps) { + fps->setHidden(!fps->getHidden()); } default: break; } } -void handleKeyUp( SDL_Keycode key ) { - switch ( key ) { +void handleKeyUp(SDL_Keycode key) { + switch (key) { case SDLK_a: mario->walkRight(); break; @@ -80,52 +80,53 @@ void handleKeyUp( SDL_Keycode key ) { } } -void moveToMarioPosition( SDLPP::Scene &scene, - SDLPP::Vec2D< double > &prev_mario ) { +void moveToMarioPosition(SDLPP::Scene &scene, + SDLPP::Vec2D &prev_mario) { auto rendDims = renderer->getDoubleDimensions(); - if ( leftStop ) { + if (leftStop) { auto left = - rendDims.getX() < 2.0 ? -( rendDims.getX() - 1 ) / 2.0 - 0.1 : -0.5; - leftStop->setPos( left, 0 ); + rendDims.getX() < 2.0 ? -(rendDims.getX() - 1) / 2.0 - 0.1 : -0.5; + leftStop->setPos(left, 0); } auto mario_pos_difference = prev_mario - mario->getAbsolutePos(); // sometimes there is a concurrency problem and prev_pos == cur_pos, in // that case move everything so Mario is standing on the left edge of the // screen - if(mario_pos_difference.getX() < 0.01 && mario_pos_difference.getX() > -0.01) { + if (mario_pos_difference.getX() < 0.01 && + mario_pos_difference.getX() > -0.01) { // 0.01 is the width of visible leftStop scene.moveEverything(-(mario->getAbsolutePos().getX() - 0.01), 0); } else { - scene.moveEverything( mario_pos_difference.getX(), 0 ); + scene.moveEverything(mario_pos_difference.getX(), 0); } scene.updateSizeAndPosition(); auto left_stop_rightmost = leftStop->getDoubleRect().first.getX() + leftStop->getDoubleRect().second.getX(); - if ( mario->getPos().getX() < left_stop_rightmost ) { - mario->setPos( left_stop_rightmost, mario->getPos().getY() ); + if (mario->getPos().getX() < left_stop_rightmost) { + mario->setPos(left_stop_rightmost, mario->getPos().getY()); } } -void pollEvents( SDLPP::Scene &scene ) { +void pollEvents(SDLPP::Scene &scene) { SDL_Event event; - while ( SDLPP::getSDLEvent( event ) ) { - switch ( event.type ) { + while (SDLPP::getSDLEvent(event)) { + switch (event.type) { case SDL_QUIT: quit = true; break; case SDL_KEYDOWN: - if ( !event.key.repeat ) { - handleKeyDown( event.key.keysym.sym, scene ); + if (!event.key.repeat) { + handleKeyDown(event.key.keysym.sym, scene); } break; case SDL_KEYUP: - handleKeyUp( event.key.keysym.sym ); + handleKeyUp(event.key.keysym.sym); break; case SDL_WINDOWEVENT: - if ( event.window.event == SDL_WINDOWEVENT_RESIZED ) { + if (event.window.event == SDL_WINDOWEVENT_RESIZED) { auto prev_mario_pos = mario->getAbsolutePos(); scene.updateSizeAndPosition(); - moveToMarioPosition( scene, prev_mario_pos ); + moveToMarioPosition(scene, prev_mario_pos); update = true; } default: @@ -134,45 +135,46 @@ void pollEvents( SDLPP::Scene &scene ) { } } -void doInput( std::shared_ptr< SDLPP::Scene > scene ) { +void doInput(std::shared_ptr scene) { FPSmanager gFPS; - SDL_initFramerate( &gFPS ); - SDL_setFramerate( &gFPS, 200 ); - while ( !quit ) { - SDL_framerateDelay( &gFPS ); - pollEvents( *scene ); - std::lock_guard< std::mutex > lock( render_mutex ); + SDL_initFramerate(&gFPS); + SDL_setFramerate(&gFPS, 200); + while (!quit) { + SDL_framerateDelay(&gFPS); + pollEvents(*scene); + std::lock_guard lock(render_mutex); scene->updateScene(); auto prev_coin_count = coin_count; auto rightmost_x = renderer->getDoubleDimensions().getX(); - for(size_t i = 0; i < moving_objects.size(); i++) { + for (size_t i = 0; i < moving_objects.size(); i++) { moving_objects[i]->checkVisibility(rightmost_x); - if(!moving_objects[i]->wasVisible()) { + if (!moving_objects[i]->wasVisible()) { continue; } - auto visitor = - getVisitor( *moving_objects[i], *scene, quit, coin_count, moving_objects ); - scene->visitCollisions( *moving_objects[i], *visitor ); - moving_objects[i]->handleVisitor( *visitor ); - auto rightmost_pos = moving_objects[i]->getAbsolutePos().getX() + - moving_objects[i]->getDoubleRect().second.getX(); - if(rightmost_pos < 0 && moving_objects[i] != mario) { + auto visitor = getVisitor(*moving_objects[i], *scene, quit, + coin_count, moving_objects); + scene->visitCollisions(*moving_objects[i], *visitor); + moving_objects[i]->handleVisitor(*visitor); + auto rightmost_pos = + moving_objects[i]->getAbsolutePos().getX() + + moving_objects[i]->getDoubleRect().second.getX(); + if (rightmost_pos < 0 && moving_objects[i] != mario) { moving_objects[i]->destroy(); } } std::vector killed_indices{}; - for(size_t i = 0; i < moving_objects.size(); i++) { - if(moving_objects[i]->getKilled()) { + for (size_t i = 0; i < moving_objects.size(); i++) { + if (moving_objects[i]->getKilled()) { killed_indices.push_back(i); } } - std::reverse( killed_indices.begin(), killed_indices.end() ); - for(auto &index : killed_indices) { + std::reverse(killed_indices.begin(), killed_indices.end()); + for (auto &index : killed_indices) { moving_objects.erase(moving_objects.begin() + index); } - if ( coin_count != prev_coin_count ) { - coins->changeText( std::to_string( coin_count ) + " COINS" ); + if (coin_count != prev_coin_count) { + coins->changeText(std::to_string(coin_count) + " COINS"); } // if player is > 0.7 of playground, move everything left auto playerX = mario->getRect().x; @@ -180,108 +182,110 @@ void doInput( std::shared_ptr< SDLPP::Scene > scene ) { auto rightBarrier = width * 0.5; auto rightmostX = scene->rightmost()->getRect().x + scene->rightmost()->getRect().w; - scene->moveEverything( - ( playerX > rightBarrier && rightmostX > width ) * - ( rightBarrier - playerX ) / width, - 0 ); + scene->moveEverything((playerX > rightBarrier && rightmostX > width) * + (rightBarrier - playerX) / width, + 0); update = update || (playerX > rightBarrier && rightmostX > width); global_frames++; } } #ifdef _WIN32 -int WINAPI wWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, - PWSTR szCmdLine, int nCmdShow ) { +int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, + PWSTR szCmdLine, int nCmdShow) { #else int main() { #endif SDLPP::init(); - SDLPP::Window w( "Mario clone!" ); - w.setResizable( true ); + SDLPP::Window w("Mario clone!"); + w.setResizable(true); - renderer = std::make_shared< SDLPP::Renderer >( w ); - renderer->setBlendMode( SDL_BLENDMODE_BLEND ); + renderer = std::make_shared(w); + renderer->setBlendMode(SDL_BLENDMODE_BLEND); // prepare global vars - g_terrain_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); - g_enemies_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/enemies.png", MARIO_OVERWORLD_COLORKEY ); + g_terrain_texture = std::make_shared( + renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY); + g_enemies_texture = std::make_shared( + renderer, "sprites/enemies.png", MARIO_OVERWORLD_COLORKEY); - auto scene = std::make_shared< SDLPP::Scene >( renderer ); + auto scene = std::make_shared(renderer); g_playground = scene; - auto bg = std::make_shared< SDLPP::RectangleRender >( - 0, 0, 10, 10, renderer, MARIO_OVERWORLD_COLORKEY, true ); + auto bg = std::make_shared( + 0, 0, 10, 10, renderer, MARIO_OVERWORLD_COLORKEY, true); bg->setPermanent(); bg->setStatic(); - bg->setId( 1 ); - scene->addObject( bg ); - g_mario_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); - g_translucent_terrain_texture = std::make_shared< SDLPP::Texture >( - renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); - g_translucent_terrain_texture->setAlpha( 100 ); - mario = std::make_shared< Mario >( renderer ); - scene->addObject( mario ); + bg->setId(1); + scene->addObject(bg); + g_mario_texture = std::make_shared( + renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY); + g_translucent_terrain_texture = std::make_shared( + renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY); + g_translucent_terrain_texture->setAlpha(100); + mario = std::make_shared(renderer); + scene->addObject(mario); auto defeat = - std::make_shared< SDLPP::RectangleRender >( 0, 1.01, 0, 0, renderer ); - defeat->setId( DEATH_ID ); - defeat->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); + std::make_shared(0, 1.01, 0, 0, renderer); + defeat->setId(DEATH_ID); + defeat->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); defeat->setPermanent(); - auto defeatCol = SDLPP::RectColider( -1, 0, -1, -1 ); + auto defeatCol = SDLPP::RectColider(-1, 0, -1, -1); defeatCol.setInfinite(); - defeat->addCollision( defeatCol ); + defeat->addCollision(defeatCol); - scene->addObject( defeat ); + scene->addObject(defeat); - leftStop = std::make_shared< SDLPP::RectangleRender >( -0.1, 0, 0.11, 0, - renderer ); - leftStop->setId( STOP_MOVEMENT ); - leftStop->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); + leftStop = + std::make_shared(-0.1, 0, 0.11, 0, renderer); + leftStop->setId(STOP_MOVEMENT); + leftStop->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); leftStop->setPermanent(); - auto leftStopCol = SDLPP::RectColider( 0, -1, 1, -1 ); + auto leftStopCol = SDLPP::RectColider(0, -1, 1, -1); leftStopCol.setInfinite(); - leftStop->addCollision( leftStopCol ); - leftStop->setColiderColor( "#FF00FF" ); - scene->addObject( leftStop ); + leftStop->addCollision(leftStopCol); + leftStop->setColiderColor("#FF00FF"); + scene->addObject(leftStop); - loadMap( scene, mario, "test_binary2.bin" ); + loadMap(scene, mario, "test_binary2.bin"); - auto font = std::make_shared< SDLPP::Font >( "testfont.ttf", 36 ); - fps = std::make_shared< SDLPP::TextRenderer >( + auto font = std::make_shared("testfont.ttf", 36); + fps = std::make_shared( 0.2, 0, 0.78, 0.1, renderer, font, "0fps", "#FFFFFF", "#000000", 0.1, - SDLPP_TEXT_RIGHT ); - fps->setAlignment( SDLPP::OBJ_END, SDLPP::OBJ_START ); - fps->setId( 0 ); + SDLPP_TEXT_RIGHT); + fps->setAlignment(SDLPP::OBJ_END, SDLPP::OBJ_START); + fps->setId(0); fps->setPermanent(); - fps->setHidden( true ); - scene->addObject( fps ); + fps->setHidden(true); + scene->addObject(fps); - coins = std::make_shared< SDLPP::TextRenderer >( + coins = std::make_shared( 0.2, 0, 0.78, 0.1, renderer, font, "0 COINS", "#FFFFFF", "#000000", 0.1, - SDLPP_TEXT_RIGHT ); - coins->setAlignment( SDLPP::OBJ_START, SDLPP::OBJ_START ); - coins->setId( 0 ); + SDLPP_TEXT_RIGHT); + coins->setAlignment(SDLPP::OBJ_START, SDLPP::OBJ_START); + coins->setId(0); coins->setPermanent(); - scene->addObject( coins ); + scene->addObject(coins); FPSmanager gFPS; - SDL_initFramerate( &gFPS ); - SDL_setFramerate( &gFPS, 60 ); + SDL_initFramerate(&gFPS); + SDL_setFramerate(&gFPS, 60); auto base = SDL_GetTicks(); int frames = 0; - scene->moveEverything( -mario->getDoubleRect().first.getX() + 0.2, 0 ); + scene->moveEverything(-mario->getDoubleRect().first.getX() + 0.2, 0); update = true; std::unordered_set background_ids = { - HILL_INCLINE_ID, HILL_DECLINE_ID, HILL_DOTS_RIGHT_ID, HILL_DOTS_LEFT_ID, - HILL_FILL_ID, HILL_TOP_ID, BUSH_LEFT_ID, BUSH_MIDDLE_ID, BUSH_RIGHT_ID, + HILL_INCLINE_ID, HILL_DECLINE_ID, HILL_DOTS_RIGHT_ID, + HILL_DOTS_LEFT_ID, HILL_FILL_ID, HILL_TOP_ID, + BUSH_LEFT_ID, BUSH_MIDDLE_ID, BUSH_RIGHT_ID, CLOUD_LEFT_BOTTOM_ID, CLOUD_MIDDLE_BOTTOM_ID, CLOUD_RIGHT_BOTTOM_ID, - CLOUD_LEFT_TOP_ID, CLOUD_MIDDLE_TOP_ID, CLOUD_RIGHT_TOP_ID, - CASTLE_LEFT_ID, CASTLE_RIGHT_ID, CASTLE_BLACK_ID, CASTLE_ENTRY_ID, - CASTLE_TOWER_ID, CASTLE_TOWER_FILLED_ID, WATER_TOP_ID, WATER_FILL_ID }; + CLOUD_LEFT_TOP_ID, CLOUD_MIDDLE_TOP_ID, CLOUD_RIGHT_TOP_ID, + CASTLE_LEFT_ID, CASTLE_RIGHT_ID, CASTLE_BLACK_ID, + CASTLE_ENTRY_ID, CASTLE_TOWER_ID, CASTLE_TOWER_FILLED_ID, + WATER_TOP_ID, WATER_FILL_ID + }; scene->setBackgroundObjectIDs(background_ids); scene->updateBackgroundObjectZIndex(); @@ -290,35 +294,35 @@ int main() { std::unordered_set moving_object_ids = { GOOMBA_ID, }; - for(auto &obj : scene->getObjects(moving_object_ids)) { + for (auto &obj : scene->getObjects(moving_object_ids)) { moving_objects.push_back(std::dynamic_pointer_cast(obj)); } - std::thread inputThread( doInput, scene ); + std::thread inputThread(doInput, scene); SDL_PumpEvents(); scene->updateSizeAndPosition(); scene->renderScene(); renderer->presentRenderer(); update = true; - while ( !quit ) { - SDL_framerateDelay( &gFPS ); + while (!quit) { + SDL_framerateDelay(&gFPS); SDL_PumpEvents(); - std::lock_guard< std::mutex > lock( render_mutex ); + std::lock_guard lock(render_mutex); mario->setStanding(); - if ( update ) { + if (update) { scene->updateSizeAndPosition(); update = false; } scene->renderScene(); renderer->presentRenderer(); frames++; - if ( SDL_GetTicks() - base >= 1000 ) { - if ( global_frames < frames ) { + if (SDL_GetTicks() - base >= 1000) { + if (global_frames < frames) { frames = global_frames; } global_frames = 0; - fps->changeText( std::to_string( frames ) + " fps" ); + fps->changeText(std::to_string(frames) + " fps"); frames = 0; base = SDL_GetTicks(); } diff --git a/mario/maploader.cpp b/mario/maploader.cpp index 27f4691..5b0c56d 100644 --- a/mario/maploader.cpp +++ b/mario/maploader.cpp @@ -11,213 +11,212 @@ #define WIDE_TERRAIN_HAS_ADDITIONAL 0x8000 #define ADDITIONAL_IS_MOD 0x80 -void loadMap( std::shared_ptr< SDLPP::Scene > &scene, - std::shared_ptr< SDLPP::RenderObject > mario, - const std::string &file ) { - std::vector< mapColumnType > tmp = {}; - loadMap( scene, mario, file, tmp, false ); - scene->moveZTop( mario ); +void loadMap(std::shared_ptr &scene, + std::shared_ptr mario, + const std::string &file) { + std::vector tmp = {}; + loadMap(scene, mario, file, tmp, false); + scene->moveZTop(mario); } -uint8_t read8Bits( std::ifstream &file ) { +uint8_t read8Bits(std::ifstream &file) { uint8_t data; - file.read( ( char * )&data, sizeof( uint8_t ) / sizeof( char ) ); + file.read((char *)&data, sizeof(uint8_t) / sizeof(char)); return data; } -void write8Bits( std::ofstream &file, uint8_t data ) { - file.write( ( char * )&data, sizeof( uint8_t ) / sizeof( char ) ); +void write8Bits(std::ofstream &file, uint8_t data) { + file.write((char *)&data, sizeof(uint8_t) / sizeof(char)); } -uint16_t read16Bits( std::ifstream &file ) { +uint16_t read16Bits(std::ifstream &file) { uint16_t data; - file.read( ( char * )&data, sizeof( uint16_t ) / sizeof( char ) ); + file.read((char *)&data, sizeof(uint16_t) / sizeof(char)); return data; } -void write16Bits( std::ofstream &file, uint16_t data ) { - file.write( ( char * )&data, sizeof( uint16_t ) / sizeof( char ) ); +void write16Bits(std::ofstream &file, uint16_t data) { + file.write((char *)&data, sizeof(uint16_t) / sizeof(char)); } -std::pair< uint16_t, uint8_t > separateWideTerrain( uint16_t wide_terrain ) { - uint8_t terrain_type = ( wide_terrain & 0xF000 ) >> 12; - uint16_t terrain_id = ( wide_terrain & 0x0FFF ) | BLOCK_PREFIX; +std::pair separateWideTerrain(uint16_t wide_terrain) { + uint8_t terrain_type = (wide_terrain & 0xF000) >> 12; + uint16_t terrain_id = (wide_terrain & 0x0FFF) | BLOCK_PREFIX; return { terrain_id, terrain_type }; } -std::pair< uint8_t, uint8_t > separateAdditionalData( uint8_t data ) { +std::pair separateAdditionalData(uint8_t data) { auto id = data & 0x0F; - auto type = ( data & 0xF0 ) >> 4; + auto type = (data & 0xF0) >> 4; return { id, type }; } -uint16_t combineTerrain( uint16_t id, uint8_t type ) { +uint16_t combineTerrain(uint16_t id, uint8_t type) { uint16_t wide_terrain = type; wide_terrain = wide_terrain << 12; wide_terrain |= 0x0FFF & id; return wide_terrain; } -uint8_t combineAdditionalData( uint8_t id, uint8_t type ) { +uint8_t combineAdditionalData(uint8_t id, uint8_t type) { return type << 4 | id; } -MapObject parseBlock( std::ifstream &map_file ) { +MapObject parseBlock(std::ifstream &map_file) { uint8_t character_type = 0; uint8_t character_id = 0; uint32_t modifier_id = 0; uint8_t modifier_data = 0; - uint16_t wide_terrain = read16Bits( map_file ); - auto terrain = separateWideTerrain( wide_terrain ); + uint16_t wide_terrain = read16Bits(map_file); + auto terrain = separateWideTerrain(wide_terrain); uint16_t terrain_id = terrain.first; uint8_t terrain_type = terrain.second; - if ( terrain_type & TERRAIN_TYPE_HAS_ADDITIONAL ) { - uint8_t additional_data = read8Bits( map_file ); + if (terrain_type & TERRAIN_TYPE_HAS_ADDITIONAL) { + uint8_t additional_data = read8Bits(map_file); terrain_type &= ~TERRAIN_TYPE_HAS_ADDITIONAL; - if ( additional_data & ADDITIONAL_IS_MOD ) { + if (additional_data & ADDITIONAL_IS_MOD) { additional_data &= ~ADDITIONAL_IS_MOD; - auto modifier = separateAdditionalData( additional_data ); + auto modifier = separateAdditionalData(additional_data); // TODO swap modifier id and data modifier_id = modifier.second | 0x6000; modifier_data = modifier.first; } else { // character - auto character = separateAdditionalData( additional_data ); + auto character = separateAdditionalData(additional_data); character_id = character.first; character_type = character.second; } } - return MapObject( terrain_id, terrain_type, character_id, character_type, - modifier_id, modifier_data ); + return MapObject(terrain_id, terrain_type, character_id, character_type, + modifier_id, modifier_data); } // editor loader -void loadMap( std::shared_ptr< SDLPP::Scene > &scene, - std::shared_ptr< SDLPP::RenderObject > &mario, - const std::string &file, - std::vector< mapColumnType > &objects, bool editor, - size_t editor_width ) { +void loadMap(std::shared_ptr &scene, + std::shared_ptr &mario, + const std::string &file, std::vector &objects, + bool editor, size_t editor_width) { auto renderer = scene->getRendererShared(); std::ifstream map_file; - map_file.open( file, std::ios::in | std::ios::binary ); + map_file.open(file, std::ios::in | std::ios::binary); uint16_t cols; - map_file.read( ( char * )&cols, sizeof( uint16_t ) / sizeof( char ) ); - if ( editor ) { - objects.resize( cols ); + map_file.read((char *)&cols, sizeof(uint16_t) / sizeof(char)); + if (editor) { + objects.resize(cols); } mapColumnType *col = nullptr; - for ( uint16_t i = 0; i < cols; i++ ) { - if ( editor ) { + for (uint16_t i = 0; i < cols; i++) { + if (editor) { col = &objects[i]; } - for ( int j = 0; j < 16; j++ ) { - auto block = parseBlock( map_file ); - if ( editor ) { - col->at( j ) = block; + for (int j = 0; j < 16; j++) { + auto block = parseBlock(map_file); + if (editor) { + col->at(j) = block; } bool destructible = false; bool removeCollisions = false; int coinCount = 0; bool mushroom = false; - if ( !editor && - block.getModifierId() == DESTRUCTIBLE_MODIFIER_ID ) { + if (!editor && block.getModifierId() == DESTRUCTIBLE_MODIFIER_ID) { destructible = true; } - if ( !editor && - block.getModifierId() == BACKGROUND_MODIFIER_ID ) { + if (!editor && block.getModifierId() == BACKGROUND_MODIFIER_ID) { destructible = false; removeCollisions = true; } - if ( !editor && - block.getModifierId() == COIN_MODIFIER_ID ) { + if (!editor && block.getModifierId() == COIN_MODIFIER_ID) { coinCount = block.getModifierData(); } - if ( !editor && block.getModifierId() == MUSHROOM_MODIFIER_ID ) { + if (!editor && block.getModifierId() == MUSHROOM_MODIFIER_ID) { mushroom = true; } // TODO add modifiers to createTerrainBlock - if(block.getTerrainId() != 0) { - auto obj = createTerrainBlock( - block.getTerrainId(), block.getTerrainType(), - renderer, i, j, destructible, editor ); - if(obj != nullptr) { + if (block.getTerrainId() != 0) { + auto obj = createTerrainBlock(block.getTerrainId(), + block.getTerrainType(), renderer, + i, j, destructible, editor); + if (obj != nullptr) { obj->setCoinCount(coinCount); - if(mushroom) { + if (mushroom) { obj->addMushroom(); } - if(removeCollisions) { + if (removeCollisions) { obj->removeCollisions(); } - if ( obj != nullptr ) { - if ( editor ) { - obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID ); + if (obj != nullptr) { + if (editor) { + obj->getCollisions()[0]->setId(EDITOR_TERRAIN_ID); } - scene->addObject( obj ); + scene->addObject(obj); } } } - if ( block.hasCharacter() ) { - if ( block.getCharacterId() == MARIO_ID ) { - if ( editor ) { - scene->addObject( createMario( - block.getCharacterType(), - renderer, i, j, true ) ); + if (block.hasCharacter()) { + if (block.getCharacterId() == MARIO_ID) { + if (editor) { + scene->addObject(createMario(block.getCharacterType(), + renderer, i, j, true)); mario = - scene->getObject( scene->getObjects().size() - 1 ); + scene->getObject(scene->getObjects().size() - 1); } else { - mario->setPos( i * BLOCK_SIZE, - 1 - ( 16 - j ) * BLOCK_SIZE ); + mario->setPos(i * BLOCK_SIZE, + 1 - (16 - j) * BLOCK_SIZE); } } else { auto obj = createTerrainBlock( - block.getCharacterId(), block.getCharacterType(), - renderer, i, j, destructible, editor); - dynamic_cast< MarioBlock * >( obj.get() )->setTerrain( false ); - if ( editor ) { - obj->getCollisions()[0]->setId( EDITOR_CHARACTER_ID ); + block.getCharacterId(), block.getCharacterType(), + renderer, i, j, destructible, editor); + dynamic_cast(obj.get())->setTerrain(false); + if (editor) { + obj->getCollisions()[0]->setId(EDITOR_CHARACTER_ID); } scene->addObject(obj); } } - if ( editor && block.hasModifier() ) { + if (editor && block.hasModifier()) { // TODO createModifierBlock with data - auto mod = createTerrainBlock( - block.getModifierId(), LandType::OVERWORLD, renderer, i, j, - false, editor ); + auto mod = createTerrainBlock(block.getModifierId(), + LandType::OVERWORLD, renderer, i, + j, false, editor); mod->setData(block.getModifierData()); mod->setTextureKeepSRC(g_translucent_mod_texture); - mod->getCollisions()[0]->setId( EDITOR_TERRAIN_ID ); - dynamic_cast< MarioBlock * >( mod.get() )->setTerrain( false ); - scene->addObject( mod ); + mod->getCollisions()[0]->setId(EDITOR_TERRAIN_ID); + dynamic_cast(mod.get())->setTerrain(false); + scene->addObject(mod); } } } - if ( editor && objects.size() < editor_width ) { - objects.resize( editor_width ); + if (editor && objects.size() < editor_width) { + objects.resize(editor_width); } } -void saveMap( const std::string &file, std::vector< mapColumnType > &objects ) { +void saveMap(const std::string &file, std::vector &objects) { std::ofstream output_file; - output_file.open( file, std::ios::out | std::ios::binary ); + output_file.open(file, std::ios::out | std::ios::binary); uint16_t cols = objects.size(); - output_file.write( ( char * )&cols, sizeof( uint16_t ) / sizeof( char ) ); - for ( auto &col : objects ) { - for ( int i = 0; i < 16; i++ ) { + output_file.write((char *)&cols, sizeof(uint16_t) / sizeof(char)); + for (auto &col : objects) { + for (int i = 0; i < 16; i++) { auto &block = col[i]; - auto wide_terrain = combineTerrain(block.getTerrainId(), block.getTerrainType()); + auto wide_terrain = + combineTerrain(block.getTerrainId(), block.getTerrainType()); // if block has additional data it needs to indicate it - if ( block.hasCharacter() || block.hasModifier() ) { + if (block.hasCharacter() || block.hasModifier()) { wide_terrain |= WIDE_TERRAIN_HAS_ADDITIONAL; } write16Bits(output_file, wide_terrain); uint8_t additional_data = 0; - if ( block.hasCharacter() ) { - additional_data = combineAdditionalData(block.getCharacterId(), block.getCharacterType()); - } else if ( block.hasModifier() ) { + if (block.hasCharacter()) { + additional_data = combineAdditionalData( + block.getCharacterId(), block.getCharacterType()); + } else if (block.hasModifier()) { // TODO seriously change order of id/data!!! - // we have IDs like 0x600X but only X is useful data, the 0x6 at the beginning is to differentiate mods from characters - additional_data = combineAdditionalData(block.getModifierData(), block.getModifierId() & 0x000F); + // we have IDs like 0x600X but only X is useful data, the 0x6 at + // the beginning is to differentiate mods from characters + additional_data = combineAdditionalData( + block.getModifierData(), block.getModifierId() & 0x000F); additional_data |= ADDITIONAL_IS_MOD; } - if ( additional_data ) { + if (additional_data) { write8Bits(output_file, additional_data); } } diff --git a/mario/maploader.hpp b/mario/maploader.hpp index 2a02ebd..0a67419 100644 --- a/mario/maploader.hpp +++ b/mario/maploader.hpp @@ -5,15 +5,15 @@ #include "../sdlpp/sdlpp_rectrenderer.hpp" #include "mapobject.hpp" -typedef std::array< MapObject, 16 > mapColumnType; +typedef std::array mapColumnType; -void loadMap( std::shared_ptr< SDLPP::Scene > &scene, - std::shared_ptr< SDLPP::RenderObject > mario, - const std::string &file ); -void loadMap( std::shared_ptr< SDLPP::Scene > &scene, - std::shared_ptr< SDLPP::RenderObject > &mario, - const std::string &file, - std::vector< mapColumnType > &objects, bool editor = false, size_t editor_width = 0 ); -void saveMap( const std::string &file, std::vector< mapColumnType > &objects ); +void loadMap(std::shared_ptr &scene, + std::shared_ptr mario, + const std::string &file); +void loadMap(std::shared_ptr &scene, + std::shared_ptr &mario, + const std::string &file, std::vector &objects, + bool editor = false, size_t editor_width = 0); +void saveMap(const std::string &file, std::vector &objects); #endif diff --git a/mario/mapobject.cpp b/mario/mapobject.cpp index 5362df2..feaaf31 100644 --- a/mario/mapobject.cpp +++ b/mario/mapobject.cpp @@ -1,49 +1,48 @@ #include "mapobject.hpp" -MapObject::MapObject( uint16_t terrain_id, LandType::Value terrain_type, - uint8_t character_id, LandType::Value character_type, - uint32_t modifier_id, uint8_t modifier_data ) { +MapObject::MapObject(uint16_t terrain_id, LandType::Value terrain_type, + uint8_t character_id, LandType::Value character_type, + uint32_t modifier_id, uint8_t modifier_data) { setTerrain(terrain_id, terrain_type); - if(character_id != 0) + if (character_id != 0) setCharacter(character_id, character_type); - if(modifier_id != 0) + if (modifier_id != 0) setModifier(modifier_id, modifier_data); } -MapObject::MapObject( uint16_t terrain_id, uint8_t terrain_type, - uint8_t character_id, uint8_t character_type, - uint32_t modifier_id, uint8_t modifier_data ) - : MapObject( terrain_id, static_cast< LandType::Value >( terrain_type ), - character_id, - static_cast< LandType::Value >( character_type ), - modifier_id, modifier_data ) {} +MapObject::MapObject(uint16_t terrain_id, uint8_t terrain_type, + uint8_t character_id, uint8_t character_type, + uint32_t modifier_id, uint8_t modifier_data) + : MapObject(terrain_id, static_cast(terrain_type), + character_id, static_cast(character_type), + modifier_id, modifier_data) {} -void MapObject::setTerrain( uint16_t id, LandType::Value land_type ) { +void MapObject::setTerrain(uint16_t id, LandType::Value land_type) { terrain_id = id; terrain_type = land_type; } -void MapObject::setTerrain( uint16_t id, uint8_t land_type ) { - setTerrain( id, static_cast< LandType::Value >( land_type ) ); +void MapObject::setTerrain(uint16_t id, uint8_t land_type) { + setTerrain(id, static_cast(land_type)); } -void MapObject::setCharacter( uint8_t id, LandType::Value land_type ) { +void MapObject::setCharacter(uint8_t id, LandType::Value land_type) { character_id = id; character_type = land_type; - if(hasModifier()) { + if (hasModifier()) { modifier_id = 0; modifier_data = 0; } } -void MapObject::setCharacter( uint8_t id, uint8_t land_type ) { - setCharacter( id, static_cast< LandType::Value >( land_type ) ); +void MapObject::setCharacter(uint8_t id, uint8_t land_type) { + setCharacter(id, static_cast(land_type)); } -void MapObject::setModifier( uint32_t id, uint8_t data ) { +void MapObject::setModifier(uint32_t id, uint8_t data) { modifier_id = id; modifier_data = data; - if(hasCharacter()) { + if (hasCharacter()) { character_id = 0; character_type = LandType::OVERWORLD; } @@ -54,14 +53,14 @@ void MapObject::unsetTerrain() { } void MapObject::unsetModifier() { - if ( hasModifier() ) { - setModifier( 0, 0 ); + if (hasModifier()) { + setModifier(0, 0); } } void MapObject::unsetCharacter() { - if ( hasCharacter() ) { - setCharacter( 0, 0 ); + if (hasCharacter()) { + setCharacter(0, 0); } } diff --git a/mario/mapobject.hpp b/mario/mapobject.hpp index ac0629c..0a39848 100644 --- a/mario/mapobject.hpp +++ b/mario/mapobject.hpp @@ -6,17 +6,17 @@ class MapObject { public: MapObject() = default; - MapObject( uint16_t terrain_id, uint8_t terrain_type, uint8_t character_id, - uint8_t character_type, uint32_t modifier_id, - uint8_t modifier_data ); - MapObject( uint16_t terrain_id, LandType::Value terrain_type, - uint8_t character_id, LandType::Value character_type, - uint32_t modifier_id, uint8_t modifier_data ); - void setTerrain( uint16_t id, LandType::Value land_type ); - void setTerrain( uint16_t id, uint8_t land_type ); - void setCharacter( uint8_t id, LandType::Value land_type ); - void setCharacter( uint8_t id, uint8_t land_type ); - void setModifier( uint32_t id, uint8_t data ); + MapObject(uint16_t terrain_id, uint8_t terrain_type, uint8_t character_id, + uint8_t character_type, uint32_t modifier_id, + uint8_t modifier_data); + MapObject(uint16_t terrain_id, LandType::Value terrain_type, + uint8_t character_id, LandType::Value character_type, + uint32_t modifier_id, uint8_t modifier_data); + void setTerrain(uint16_t id, LandType::Value land_type); + void setTerrain(uint16_t id, uint8_t land_type); + void setCharacter(uint8_t id, LandType::Value land_type); + void setCharacter(uint8_t id, uint8_t land_type); + void setModifier(uint32_t id, uint8_t data); void unsetTerrain(); void unsetModifier(); void unsetCharacter(); diff --git a/mario/mario.cpp b/mario/mario.cpp index f848838..383d1be 100644 --- a/mario/mario.cpp +++ b/mario/mario.cpp @@ -4,40 +4,40 @@ #include "sprites.hpp" #include "visitors/mario_visitor.hpp" -Mario::Mario(int x, int y, const std::shared_ptr< SDLPP::Renderer > &renderer) : MarioBlock(x, y, renderer, g_mario_texture, MARIO_STANDING_SRC) { - setAnimationFrames( MARIO_WALK_ANIM ); - setId( MARIO_ID ); - setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); - setAnimationSpeed( 12.5 ); +Mario::Mario(int x, int y, const std::shared_ptr &renderer) + : MarioBlock(x, y, renderer, g_mario_texture, MARIO_STANDING_SRC) { + setAnimationFrames(MARIO_WALK_ANIM); + setId(MARIO_ID); + setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); + setAnimationSpeed(12.5); pauseAnimation(); - setMovement( 0, 0 ); - setMovementSpeed( 1 ); - auto bottom_detect = SDLPP::RectColider( 0.2, 1, 0.6, 0, MARIO_FLOOR_DETECT ); + setMovement(0, 0); + setMovementSpeed(1); + auto bottom_detect = SDLPP::RectColider(0.2, 1, 0.6, 0, MARIO_FLOOR_DETECT); bottom_detect.setColor("#FF0000"); bottom_detect.setOutlineColor("#FF0000"); bottom_detect.setMinHeight(1); addCollision(bottom_detect); + addCollision(SDLPP::RectColider(0, 0.25, 0.1, 0.6, MARIO_LEFT_SIDE_DETECT)); addCollision( - SDLPP::RectColider( 0, 0.25, 0.1, 0.6, MARIO_LEFT_SIDE_DETECT ) ); - addCollision( - SDLPP::RectColider( 0.9, 0.25, 0.1, 0.6, MARIO_RIGHT_SIDE_DETECT ) ); - addCollision( - SDLPP::RectColider( 0, 0, 0.1, 0.1, MARIO_TOP_LEFT_DETECT ) ); - addCollision( - SDLPP::RectColider( 0.9, 0, 0.1, 0.1, MARIO_TOP_LEFT_DETECT ) ); - top_collision = std::make_shared( 0.5, 0, 0.2, 0.15, MARIO_TOP_DETECT ); - addCollision( top_collision ); - addCollision( SDLPP::RectColider( 0, 1, 1, 0.2, MARIO_ENEMY_DETECT ) ); + SDLPP::RectColider(0.9, 0.25, 0.1, 0.6, MARIO_RIGHT_SIDE_DETECT)); + addCollision(SDLPP::RectColider(0, 0, 0.1, 0.1, MARIO_TOP_LEFT_DETECT)); + addCollision(SDLPP::RectColider(0.9, 0, 0.1, 0.1, MARIO_TOP_LEFT_DETECT)); + top_collision = std::make_shared(0.5, 0, 0.2, 0.15, + MARIO_TOP_DETECT); + addCollision(top_collision); + addCollision(SDLPP::RectColider(0, 1, 1, 0.2, MARIO_ENEMY_DETECT)); setColiderColor("#FF0000"); - setStatic( false ); + setStatic(false); bounce_speed *= 4; } -Mario::Mario(const std::shared_ptr< SDLPP::Renderer > &renderer) : Mario(0, 0, renderer) {} +Mario::Mario(const std::shared_ptr &renderer) + : Mario(0, 0, renderer) {} void Mario::walkLeft() { - if(on_ground) + if (on_ground) resumeAnimation(); - addMovement( -side_movement, 0 ); - if ( getMovement().getX() < 0 && faces_right ) { + addMovement(-side_movement, 0); + if (getMovement().getX() < 0 && faces_right) { flipHorizontally(); top_collision->setPos(0.3, 0); updateSizeAndPosition(); @@ -46,10 +46,10 @@ void Mario::walkLeft() { } void Mario::walkRight() { - if(on_ground) + if (on_ground) resumeAnimation(); - addMovement( side_movement, 0 ); - if ( getMovement().getX() > 0 && !faces_right ) { + addMovement(side_movement, 0); + if (getMovement().getX() > 0 && !faces_right) { flipHorizontally(); top_collision->setPos(0.5, 0); updateSizeAndPosition(); @@ -58,70 +58,80 @@ void Mario::walkRight() { } void Mario::setStanding() { - if ( getMovement().getX() == 0 ) { + if (getMovement().getX() == 0) { pauseAnimation(); } } void Mario::handleVisitor(SDLPP::Visitor &visitor) { #ifndef EDITOR - // TODO - https://web.archive.org/web/20130807122227/http://i276.photobucket.com/albums/kk21/jdaster64/smb_playerphysics.png - auto &m_visitor = dynamic_cast(visitor); + // TODO - + // https://web.archive.org/web/20130807122227/http://i276.photobucket.com/albums/kk21/jdaster64/smb_playerphysics.png + auto &m_visitor = dynamic_cast(visitor); // handle gravity on_ground = m_visitor.isOnGround(); - if(!jumping && on_ground) { + if (!jumping && on_ground) { resetMovementY(); setBaseRect(MARIO_STANDING_SRC); - if(getMovement().getX() != 0) + if (getMovement().getX() != 0) resumeAnimation(); // for some reason falling of the edge causes on_ground to be true, but // visitor ground_y is 0 - if(m_visitor.getGroundY() != 0) { + if (m_visitor.getGroundY() != 0) { setPos(getPos().getX(), m_visitor.getGroundY() - BLOCK_SIZE); } } // if we just left ground gravity didn't work in custom_move - if(!on_ground && !jumping && getMovement().getY() == 0) { - addMovement(0, 2*gravity_add_falling); + if (!on_ground && !jumping && getMovement().getY() == 0) { + addMovement(0, 2 * gravity_add_falling); } - if(m_visitor.topBlock() && getMovement().getY() < 0) { + if (m_visitor.topBlock() && getMovement().getY() < 0) { resetMovementY(); stop_jump = true; } - if(m_visitor.shouldBounce()) { + if (m_visitor.shouldBounce()) { addMovement(0, -bounce_speed); } // make sure Mario isn't stuck inside a wall // TODO more readable function names - if ( m_visitor.isStopped() ) { - setPos( m_visitor.getStopX(), getPos().getY()); - } else if ( m_visitor.canGoLeft() != m_visitor.canGoRight() && !(on_ground && m_visitor.getMovementBlockage().getY() > getPos().getY() + BLOCK_SIZE/2) ) { - // only stop mario on ground if the block obstructs at least half of him (important for bug when mario lands from a high jump and is teleported if visitor is fired at wrong moment) - SDLPP::Vec2D next_pos = { m_visitor.getMovementBlockage().getX() + (m_visitor.canGoLeft() * -1 + m_visitor.canGoRight() * 1) * BLOCK_SIZE, getPos().getY() }; + if (m_visitor.isStopped()) { + setPos(m_visitor.getStopX(), getPos().getY()); + } else if (m_visitor.canGoLeft() != m_visitor.canGoRight() && + !(on_ground && m_visitor.getMovementBlockage().getY() > + getPos().getY() + BLOCK_SIZE / 2)) { + // only stop mario on ground if the block obstructs at least half of him + // (important for bug when mario lands from a high jump and is + // teleported if visitor is fired at wrong moment) + SDLPP::Vec2D next_pos = { + m_visitor.getMovementBlockage().getX() + + (m_visitor.canGoLeft() * -1 + m_visitor.canGoRight() * 1) * + BLOCK_SIZE, + getPos().getY() + }; setPos(next_pos); } else if (m_visitor.moveTop() && jumping && !stop_jump) { auto objPos = m_visitor.getRightLeftPos(); - if(objPos.getX() < getPos().getX()) { - setPos( objPos.getX() + BLOCK_SIZE, getPos().getY() ); + if (objPos.getX() < getPos().getX()) { + setPos(objPos.getX() + BLOCK_SIZE, getPos().getY()); } else { - setPos( objPos.getX() - BLOCK_SIZE, getPos().getY() ); + setPos(objPos.getX() - BLOCK_SIZE, getPos().getY()); } } - if(m_visitor.hasMushroom()) { + if (m_visitor.hasMushroom()) { setType(LandType::UNDERWORLD); } #endif } void Mario::jump() { - if(!on_ground) + if (!on_ground) return; jumping = true; stop_jump = false; - max_jump = getPos().getY() - 3*BLOCK_SIZE; - min_jump = getPos().getY() - 1*BLOCK_SIZE; - slow_jump = getPos().getY() - 2*BLOCK_SIZE; - addMovement( 0, -jump_movement ); + max_jump = getPos().getY() - 3 * BLOCK_SIZE; + min_jump = getPos().getY() - 1 * BLOCK_SIZE; + slow_jump = getPos().getY() - 2 * BLOCK_SIZE; + addMovement(0, -jump_movement); ticks_till_gravity = base_gravity_ticks; setBaseRect(MARIO_JUMP_SRC); pauseAnimation(); @@ -131,19 +141,19 @@ void Mario::stopJump() { stop_jump = true; } -void Mario::custom_move( int ticks ) { +void Mario::custom_move(int ticks) { MarioBlock::custom_move(ticks); - if(!jumping && on_ground) + if (!jumping && on_ground) return; - if(getMovement().getY() >= 1.0625 * jump_movement) + if (getMovement().getY() >= 1.0625 * jump_movement) return; ticks_till_gravity -= ticks; - if(ticks_till_gravity < 0) { - if(getMovement().getY() > 0) { + if (ticks_till_gravity < 0) { + if (getMovement().getY() > 0) { jumping = false; addMovement(0, gravity_add_jumping); } else { - if(stop_jump) { + if (stop_jump) { addMovement(0, gravity_add_falling); } else { addMovement(0, gravity_add_jumping); diff --git a/mario/mario.hpp b/mario/mario.hpp index 0dba9d4..fd4d462 100644 --- a/mario/mario.hpp +++ b/mario/mario.hpp @@ -7,16 +7,16 @@ class Mario : public MarioBlock { public: - Mario( int x, int y, const std::shared_ptr< SDLPP::Renderer > &renderer ); - Mario( const std::shared_ptr< SDLPP::Renderer > &renderer ); + Mario(int x, int y, const std::shared_ptr &renderer); + Mario(const std::shared_ptr &renderer); void walkLeft(); void walkRight(); void setStanding(); - void handleVisitor( SDLPP::Visitor &visitor ) override; + void handleVisitor(SDLPP::Visitor &visitor) override; void jump(); void stopJump(); - void custom_move( int ticks ) override; - void visit( SDLPP::Visitor &visitor ) override; + void custom_move(int ticks) override; + void visit(SDLPP::Visitor &visitor) override; private: bool faces_right = true; @@ -32,9 +32,9 @@ private: // gravity should be added every frame in 60fps game const int base_gravity_ticks = 1000 / 60; const double gravity_add_jumping = jump_movement / 32.0; - const double gravity_add_falling = jump_movement / ( 64.0 / 7.0 ); - std::shared_ptr< SDLPP::RectColider > top_collision = nullptr; - void setWorldTypeSrc( LandType::Value world ) override; + const double gravity_add_falling = jump_movement / (64.0 / 7.0); + std::shared_ptr top_collision = nullptr; + void setWorldTypeSrc(LandType::Value world) override; }; #endif diff --git a/mario/sprites.cpp b/mario/sprites.cpp index 3736625..3aa45a4 100644 --- a/mario/sprites.cpp +++ b/mario/sprites.cpp @@ -6,17 +6,17 @@ const std::string MARIO_OVERWORLD_COLORKEY = "#93bbec"; const SDL_Rect MARIO_STANDING_SRC = { 1, 9, 16, 16 }; const SDL_Rect MARIO_DEATH_SRC = { 22, 9, 16, 16 }; -const std::vector< SDL_Rect > MARIO_WALK_ANIM = { { 43, 9, 16, 16 }, - { 60, 9, 16, 16 }, - { 77, 9, 16, 16 } }; +const std::vector MARIO_WALK_ANIM = { { 43, 9, 16, 16 }, + { 60, 9, 16, 16 }, + { 77, 9, 16, 16 } }; const SDL_Rect MARIO_CHANGE_DIR_SRC = { 98, 9, 16, 16 }; const SDL_Rect MARIO_JUMP_SRC = { 119, 9, 16, 16 }; const SDL_Rect MARIO_STANDING_BIG_SRC = { 1, 26, 16, 32 }; const SDL_Rect MARIO_DEATH_BIG_SRC = { 22, 26, 16, 32 }; -const std::vector< SDL_Rect > MARIO_WALK_BIG_ANIM = { - { 43, 26, 16, 32 }, { 60, 9, 16, 32 }, { 77, 9, 16, 32 } -}; +const std::vector MARIO_WALK_BIG_ANIM = { { 43, 26, 16, 32 }, + { 60, 9, 16, 32 }, + { 77, 9, 16, 32 } }; const SDL_Rect MARIO_CHANGE_DIR_BIG_SRC = { 98, 26, 16, 32 }; const SDL_Rect MARIO_JUMP_BIG_SRC = { 119, 26, 16, 32 }; @@ -27,70 +27,70 @@ const SDL_Rect HILL_FILL_SRC = { 171, 97, 16, 16 }; const SDL_Rect HILL_DOTS_RIGHT_SRC = { 154, 97, 16, 16 }; const SDL_Rect HILL_DOTS_LEFT_SRC = { 188, 97, 16, 16 }; const SDL_Rect HILL_TOP_SRC = { 171, 63, 16, 16 }; -const SDL_Rect BUSH_LEFT_SRC = {222,97,16,16}; -const SDL_Rect BUSH_MIDDLE_SRC = {239,97,16,16}; -const SDL_Rect BUSH_RIGHT_SRC = {256,97,16,16}; -const SDL_Rect CLOUD_LEFT_BOTTOM_SRC = {222,80,16,16}; -const SDL_Rect CLOUD_MIDDLE_BOTTOM_SRC = {239,80,16,16}; -const SDL_Rect CLOUD_RIGHT_BOTTOM_SRC = {256,80,16,16}; -const SDL_Rect CLOUD_LEFT_TOP_SRC = {222,63,16,16}; -const SDL_Rect CLOUD_MIDDLE_TOP_SRC = {239,63,16,16}; -const SDL_Rect CLOUD_RIGHT_TOP_SRC = {256,63,16,16}; -const SDL_Rect PIPE_LEFT_BOTTOM_SRC = {103, 63, 16, 16}; -const SDL_Rect PIPE_LEFT_TOP_SRC = {103, 46, 16, 16}; -const SDL_Rect PIPE_RIGHT_BOTTOM_SRC = {120, 63, 16, 16}; -const SDL_Rect PIPE_RIGHT_TOP_SRC = {120, 46, 16, 16}; -const SDL_Rect CASTLE_LEFT_SRC = {69, 131, 16, 16}; -const SDL_Rect CASTLE_RIGHT_SRC = {103, 131, 16, 16}; -const SDL_Rect CASTLE_BLACK_SRC = {86, 131, 16, 16}; -const SDL_Rect CASTLE_ENTRY_SRC = {86, 114, 16, 16}; -const SDL_Rect CASTLE_TOWER_SRC = {69, 114, 16, 16}; -const SDL_Rect CASTLE_TOWER_FILLED_SRC = {103, 114, 16, 16}; -const SDL_Rect VINE_TOP_SRC = {69, 29, 16, 16}; -const SDL_Rect VINE_BOTTOM_SRC = {69, 46, 16, 16}; -const SDL_Rect POLE_TOP_SRC = {86, 29, 16, 16}; -const SDL_Rect POLE_BOTTOM_SRC = {86, 46, 16, 16}; -const SDL_Rect FLAG_SRC = {137, 46, 16, 16}; -const SDL_Rect STEP_SRC = {86, 63, 16, 16}; -const SDL_Rect BRICK_SRC = {35, 97, 16, 16}; -const SDL_Rect BRICK_TOP_SRC = {18, 97, 16, 16}; -const SDL_Rect SIDEWAY_PIPE_END_TOP_SRC = {69, 80, 16, 16}; -const SDL_Rect SIDEWAY_PIPE_END_BOTTOM_SRC = {69, 97, 16, 16}; -const SDL_Rect SIDEWAY_PIPE_MIDDLE_TOP_SRC = {86, 80, 16, 16}; -const SDL_Rect SIDEWAY_PIPE_MIDDLE_BOTTOM_SRC = {86, 97, 16, 16}; -const SDL_Rect SIDEWAY_PIPE_CONNECTOR_TOP_SRC = {103, 80, 16, 16}; -const SDL_Rect SIDEWAY_PIPE_CONNECTOR_BOTTOM_SRC = {103, 97, 16, 16}; -const SDL_Rect TREE_PLATFORM_TOP_LEFT_SRC = {137, 12, 16, 16}; -const SDL_Rect TREE_PLATFORM_TOP_MIDDLE_SRC = {154, 12, 16, 16}; -const SDL_Rect TREE_PLATFORM_TOP_RIGHT_SRC = {171, 12, 16, 16}; -const SDL_Rect TREE_PLATFORM_BARK_SRC = {154, 46, 16, 16}; -const SDL_Rect WATER_TOP_SRC = {171, 29, 16, 16}; -const SDL_Rect WATER_FILL_SRC = {171, 46, 16, 16}; -const SDL_Rect MUSHROOM_PLATFORM_TOP_LEFT_SRC = {188, 12, 16, 16}; -const SDL_Rect MUSHROOM_PLATFORM_TOP_MIDDLE_SRC = {205, 12, 16, 16}; -const SDL_Rect MUSHROOM_PLATFORM_TOP_RIGHT_SRC = {222, 12, 16, 16}; -const SDL_Rect MUSHROOM_PLATFORM_BARK_TOP_SRC = {205, 29, 16, 16}; -const SDL_Rect MUSHROOM_PLATFORM_BARK_BOTTOM_SRC = {205, 46, 16, 16}; -const SDL_Rect TREE_BARK_SRC = {222, 46, 16, 16}; -const SDL_Rect TREE_LEAVES_SMALL_SRC = {222, 29, 16, 16}; -const SDL_Rect TREE_LEAVES_TOP_SRC = {239, 12, 16, 16}; -const SDL_Rect TREE_LEAVES_BOTTOM_SRC = {239, 29, 16, 16}; -const SDL_Rect CANNON_TOWER_SRC = {256, 46, 16, 16}; -const SDL_Rect CANNON_PEDESTAL_SRC = {256, 29, 16, 16}; -const SDL_Rect CANNON_SRC = {256, 12, 16, 16}; -const SDL_Rect COIN_SRC = {549, 202, 16, 16}; -const SDL_Rect MUSHROOM_SRC = {69, 12, 16, 16}; +const SDL_Rect BUSH_LEFT_SRC = { 222, 97, 16, 16 }; +const SDL_Rect BUSH_MIDDLE_SRC = { 239, 97, 16, 16 }; +const SDL_Rect BUSH_RIGHT_SRC = { 256, 97, 16, 16 }; +const SDL_Rect CLOUD_LEFT_BOTTOM_SRC = { 222, 80, 16, 16 }; +const SDL_Rect CLOUD_MIDDLE_BOTTOM_SRC = { 239, 80, 16, 16 }; +const SDL_Rect CLOUD_RIGHT_BOTTOM_SRC = { 256, 80, 16, 16 }; +const SDL_Rect CLOUD_LEFT_TOP_SRC = { 222, 63, 16, 16 }; +const SDL_Rect CLOUD_MIDDLE_TOP_SRC = { 239, 63, 16, 16 }; +const SDL_Rect CLOUD_RIGHT_TOP_SRC = { 256, 63, 16, 16 }; +const SDL_Rect PIPE_LEFT_BOTTOM_SRC = { 103, 63, 16, 16 }; +const SDL_Rect PIPE_LEFT_TOP_SRC = { 103, 46, 16, 16 }; +const SDL_Rect PIPE_RIGHT_BOTTOM_SRC = { 120, 63, 16, 16 }; +const SDL_Rect PIPE_RIGHT_TOP_SRC = { 120, 46, 16, 16 }; +const SDL_Rect CASTLE_LEFT_SRC = { 69, 131, 16, 16 }; +const SDL_Rect CASTLE_RIGHT_SRC = { 103, 131, 16, 16 }; +const SDL_Rect CASTLE_BLACK_SRC = { 86, 131, 16, 16 }; +const SDL_Rect CASTLE_ENTRY_SRC = { 86, 114, 16, 16 }; +const SDL_Rect CASTLE_TOWER_SRC = { 69, 114, 16, 16 }; +const SDL_Rect CASTLE_TOWER_FILLED_SRC = { 103, 114, 16, 16 }; +const SDL_Rect VINE_TOP_SRC = { 69, 29, 16, 16 }; +const SDL_Rect VINE_BOTTOM_SRC = { 69, 46, 16, 16 }; +const SDL_Rect POLE_TOP_SRC = { 86, 29, 16, 16 }; +const SDL_Rect POLE_BOTTOM_SRC = { 86, 46, 16, 16 }; +const SDL_Rect FLAG_SRC = { 137, 46, 16, 16 }; +const SDL_Rect STEP_SRC = { 86, 63, 16, 16 }; +const SDL_Rect BRICK_SRC = { 35, 97, 16, 16 }; +const SDL_Rect BRICK_TOP_SRC = { 18, 97, 16, 16 }; +const SDL_Rect SIDEWAY_PIPE_END_TOP_SRC = { 69, 80, 16, 16 }; +const SDL_Rect SIDEWAY_PIPE_END_BOTTOM_SRC = { 69, 97, 16, 16 }; +const SDL_Rect SIDEWAY_PIPE_MIDDLE_TOP_SRC = { 86, 80, 16, 16 }; +const SDL_Rect SIDEWAY_PIPE_MIDDLE_BOTTOM_SRC = { 86, 97, 16, 16 }; +const SDL_Rect SIDEWAY_PIPE_CONNECTOR_TOP_SRC = { 103, 80, 16, 16 }; +const SDL_Rect SIDEWAY_PIPE_CONNECTOR_BOTTOM_SRC = { 103, 97, 16, 16 }; +const SDL_Rect TREE_PLATFORM_TOP_LEFT_SRC = { 137, 12, 16, 16 }; +const SDL_Rect TREE_PLATFORM_TOP_MIDDLE_SRC = { 154, 12, 16, 16 }; +const SDL_Rect TREE_PLATFORM_TOP_RIGHT_SRC = { 171, 12, 16, 16 }; +const SDL_Rect TREE_PLATFORM_BARK_SRC = { 154, 46, 16, 16 }; +const SDL_Rect WATER_TOP_SRC = { 171, 29, 16, 16 }; +const SDL_Rect WATER_FILL_SRC = { 171, 46, 16, 16 }; +const SDL_Rect MUSHROOM_PLATFORM_TOP_LEFT_SRC = { 188, 12, 16, 16 }; +const SDL_Rect MUSHROOM_PLATFORM_TOP_MIDDLE_SRC = { 205, 12, 16, 16 }; +const SDL_Rect MUSHROOM_PLATFORM_TOP_RIGHT_SRC = { 222, 12, 16, 16 }; +const SDL_Rect MUSHROOM_PLATFORM_BARK_TOP_SRC = { 205, 29, 16, 16 }; +const SDL_Rect MUSHROOM_PLATFORM_BARK_BOTTOM_SRC = { 205, 46, 16, 16 }; +const SDL_Rect TREE_BARK_SRC = { 222, 46, 16, 16 }; +const SDL_Rect TREE_LEAVES_SMALL_SRC = { 222, 29, 16, 16 }; +const SDL_Rect TREE_LEAVES_TOP_SRC = { 239, 12, 16, 16 }; +const SDL_Rect TREE_LEAVES_BOTTOM_SRC = { 239, 29, 16, 16 }; +const SDL_Rect CANNON_TOWER_SRC = { 256, 46, 16, 16 }; +const SDL_Rect CANNON_PEDESTAL_SRC = { 256, 29, 16, 16 }; +const SDL_Rect CANNON_SRC = { 256, 12, 16, 16 }; +const SDL_Rect COIN_SRC = { 549, 202, 16, 16 }; +const SDL_Rect MUSHROOM_SRC = { 69, 12, 16, 16 }; -extern const SDL_Rect MOD_DESTRUCTIBLE_SRC = {0, 0, 16, 16}; -extern const SDL_Rect MOD_BACKGROUND_SRC = {16, 0, 16, 16}; -extern const SDL_Rect MOD_COIN_SRC = {32, 0, 16, 16}; -extern const SDL_Rect MOD_MUSHROOM_SRC = {48, 0, 16, 16}; +extern const SDL_Rect MOD_DESTRUCTIBLE_SRC = { 0, 0, 16, 16 }; +extern const SDL_Rect MOD_BACKGROUND_SRC = { 16, 0, 16, 16 }; +extern const SDL_Rect MOD_COIN_SRC = { 32, 0, 16, 16 }; +extern const SDL_Rect MOD_MUSHROOM_SRC = { 48, 0, 16, 16 }; -const SDLPP::Vec2D OVERWORLD_SHIFT = {0, 0}; -const SDLPP::Vec2D UNDERWORLD_SHIFT = {274, 0}; -const SDLPP::Vec2D WATER_SHIFT = {548, 0}; -const SDLPP::Vec2D BOWSER_SHIFT = {0, 173}; +const SDLPP::Vec2D OVERWORLD_SHIFT = { 0, 0 }; +const SDLPP::Vec2D UNDERWORLD_SHIFT = { 274, 0 }; +const SDLPP::Vec2D WATER_SHIFT = { 548, 0 }; +const SDLPP::Vec2D BOWSER_SHIFT = { 0, 173 }; -const std::vector< SDL_Rect > GOOMBA_WALK_ANIM = { { 1, 28, 16, 16 }, - { 18, 28, 16, 16 } }; -const SDL_Rect GOOMBA_DEATH_SRC = {39, 28, 16, 16}; +const std::vector GOOMBA_WALK_ANIM = { { 1, 28, 16, 16 }, + { 18, 28, 16, 16 } }; +const SDL_Rect GOOMBA_DEATH_SRC = { 39, 28, 16, 16 }; diff --git a/mario/tool_box.cpp b/mario/tool_box.cpp index 95e8573..f3c874a 100644 --- a/mario/tool_box.cpp +++ b/mario/tool_box.cpp @@ -3,7 +3,11 @@ #include "blocks.hpp" #include "sprites.hpp" -ToolBox::ToolBox(int x, int y, double start_x, double start_y, std::shared_ptr renderer, bool coliders) : SDLPP::RectangleRender(start_x + x*BLOCK_SIZE, start_y + y*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer) { +ToolBox::ToolBox(int x, int y, double start_x, double start_y, + std::shared_ptr renderer, bool coliders) + : SDLPP::RectangleRender(start_x + x * BLOCK_SIZE, + start_y + y * BLOCK_SIZE, BLOCK_SIZE, + BLOCK_SIZE, renderer) { _x = x; _y = y; setId(EDITOR_TOOL_ID); @@ -11,14 +15,14 @@ ToolBox::ToolBox(int x, int y, double start_x, double start_y, std::shared_ptr ToolBox::getIndexes() const { - return {_x, _y}; + return { _x, _y }; } -void ToolBox::visit( SDLPP::Visitor &visitor ) { - visitor.visit( *this ); +void ToolBox::visit(SDLPP::Visitor &visitor) { + visitor.visit(*this); } diff --git a/mario/tool_box.hpp b/mario/tool_box.hpp index 52e4f5f..0a77191 100644 --- a/mario/tool_box.hpp +++ b/mario/tool_box.hpp @@ -5,15 +5,17 @@ class ToolBox : public SDLPP::RectangleRender { public: - ToolBox(int x, int y, double start_x, double start_y, std::shared_ptr renderer, bool coliders = true); + ToolBox(int x, int y, double start_x, double start_y, + std::shared_ptr renderer, bool coliders = true); virtual SDLPP::Vec2D getIndexes() const; - virtual void visit( SDLPP::Visitor &visitor ) override; + virtual void visit(SDLPP::Visitor &visitor) override; uint64_t getType() const { return _type; } void setType(uint64_t type) { _type = type; } + private: int _x; int _y;