diff --git a/main.cpp b/main.cpp index 0e3e880..77dfe2b 100644 --- a/main.cpp +++ b/main.cpp @@ -12,24 +12,27 @@ bool pause = false; int pause_select = 0; int pause_max = 1; -std::vector> pause_options; +std::vector< std::shared_ptr< SDLPP::RectangleRender > > pause_options; -std::shared_ptr font; -std::shared_ptr active_scene; -std::shared_ptr pause_scene; +std::shared_ptr< SDLPP::Font > font; +std::shared_ptr< SDLPP::Scene > active_scene; +std::shared_ptr< SDLPP::Scene > pause_scene; -void doInput(std::shared_ptr scene); +void doInput( std::shared_ptr< SDLPP::Scene > scene ); void doInputPause(); class Player : public SDLPP::RectangleRender { public: - Player(double x, double y, double w, double h, std::shared_ptr &r, double _max_gravity = 1.0, uint32_t _max_gravity_time = 1000) : SDLPP::RectangleRender(x,y,w,h,r) { + Player( double x, double y, double w, double h, + std::shared_ptr< SDLPP::Renderer > &r, double _max_gravity = 1.0, + uint32_t _max_gravity_time = 1000 ) + : SDLPP::RectangleRender( x, y, w, h, r ) { max_gravity = _max_gravity; - jump_speed = 2.2*max_gravity; + jump_speed = 2.2 * max_gravity; max_gravity_time = _max_gravity_time; cur_gravity_time = max_gravity_time; } - void setGravity(bool grav) { + void setGravity( bool grav ) { gravity_enabled = grav; } void enableGravity() { @@ -51,30 +54,34 @@ public: void jump() { jumping = true; } - virtual void custom_move(int ticks) override { - auto time_portion = (static_cast(ticks)/1000); + virtual void custom_move( int ticks ) override { + auto time_portion = ( static_cast< double >( ticks ) / 1000 ); cur_gravity_time -= ticks; - auto grav = gravity_enabled * max_gravity * (max_gravity_time - cur_gravity_time)/max_gravity_time; - if( grav > max_gravity) + auto grav = gravity_enabled * max_gravity * + ( max_gravity_time - cur_gravity_time ) / max_gravity_time; + if ( grav > max_gravity ) grav = max_gravity; - // percentage of how close we are to maximum velocity of gravity (0 = we've reached max velocity, 1 = we've just started accelerating) - double division = static_cast(cur_gravity_time)/static_cast(max_gravity_time); + // percentage of how close we are to maximum velocity of gravity (0 = + // we've reached max velocity, 1 = we've just started accelerating) + double division = static_cast< double >( cur_gravity_time ) / + static_cast< double >( max_gravity_time ); // current jump speed auto jump_ = jumping * jump_speed * division; - if(division < 0.75 && division >= 0.72) { + if ( division < 0.75 && division >= 0.72 ) { // in this time frame, just hover in same place jump_ = jumping * grav; - } else if(division < 0.72) { + } else if ( division < 0.72 ) { // fall slowly jump_ = jumping * jump_speed * division * 0.15; - if(jump_ > grav) + if ( jump_ > grav ) jump_ = grav; } - if(jump_ < 0 || jump_ > jump_speed) + if ( jump_ < 0 || jump_ > jump_speed ) jump_ = 0; og_y += grav * time_portion; og_y -= jump_ * time_portion; } + private: double max_gravity = 1.0; double jump_speed = 2.0; @@ -86,21 +93,26 @@ private: class Destroyable : public SDLPP::RectangleRender { public: - Destroyable(double x, double y, double w, double h, std::shared_ptr &r) : SDLPP::RectangleRender(x,y,w,h,r) {} - Destroyable(double x, double y, double w, double h, std::shared_ptr &r, int destruction_time) : SDLPP::RectangleRender(x,y,w,h,r) { + Destroyable( double x, double y, double w, double h, + std::shared_ptr< SDLPP::Renderer > &r ) + : SDLPP::RectangleRender( x, y, w, h, r ) {} + Destroyable( double x, double y, double w, double h, + std::shared_ptr< SDLPP::Renderer > &r, int destruction_time ) + : SDLPP::RectangleRender( x, y, w, h, r ) { destruction_countdown = destruction_time; } - virtual void specialAction(int code) override { - if(code == DESTROYABLE_DESTROY) + virtual void specialAction( int code ) override { + if ( code == DESTROYABLE_DESTROY ) startDestruction(); } - virtual void custom_move(int ticks) override { - if(destruction) { + virtual void custom_move( int ticks ) override { + if ( destruction ) { destruction_countdown -= ticks; - if(destruction_countdown <= 0) + if ( destruction_countdown <= 0 ) destroy(); } } + private: void startDestruction() { destruction = true; @@ -109,70 +121,75 @@ private: int destruction_countdown = 3000; }; -std::shared_ptr player; +std::shared_ptr< Player > player; bool quit = false; -void addStuff(SDLPP::Scene &scene, std::shared_ptr &r) { - auto bg = std::make_shared(0,0,10,10,r,"#ebdbb2FF", true); - bg->setId(123); - bg->setPermanent(true); - scene.addObject(bg); - std::shared_ptr stone; +void addStuff( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer > &r ) { + auto bg = std::make_shared< SDLPP::RectangleRender >( 0, 0, 10, 10, r, + "#ebdbb2FF", true ); + bg->setId( 123 ); + bg->setPermanent( true ); + scene.addObject( bg ); + std::shared_ptr< Destroyable > stone; double posx = 0; - while(posx < 3) { - stone = std::make_shared(posx,0.5,0.15,0.1,r, 1000); - stone->addCollision(SDLPP::Rect(0,0,1,1)); - stone->setColor("#222222FF"); - stone->setId(STONE_ID); - stone->setColiderColor("FF0000"); - scene.addObject(stone); + while ( posx < 3 ) { + stone = + std::make_shared< Destroyable >( posx, 0.5, 0.15, 0.1, r, 1000 ); + stone->addCollision( SDLPP::Rect( 0, 0, 1, 1 ) ); + stone->setColor( "#222222FF" ); + stone->setId( STONE_ID ); + stone->setColiderColor( "FF0000" ); + scene.addObject( stone ); posx += 0.45; } - auto x = std::make_shared(0,0,0.2,0.2, r); - x->addCollision(SDLPP::Rect(0.3,0.7,0.05,0.31)); - x->addCollision(SDLPP::Rect(0.65,0.7,0.05,0.31)); - x->addCollision(SDLPP::Rect(0.2,0.3,0.6,0.45)); - x->addCollision(SDLPP::Circle(0.5,0.15,0.3)); - x->setColor("E164B7"); - x->setId(PLAYER_ID); - x->setColiderColor("00FF00"); - scene.addObject(x); + auto x = std::make_shared< Player >( 0, 0, 0.2, 0.2, r ); + x->addCollision( SDLPP::Rect( 0.3, 0.7, 0.05, 0.31 ) ); + x->addCollision( SDLPP::Rect( 0.65, 0.7, 0.05, 0.31 ) ); + x->addCollision( SDLPP::Rect( 0.2, 0.3, 0.6, 0.45 ) ); + x->addCollision( SDLPP::Circle( 0.5, 0.15, 0.3 ) ); + x->setColor( "E164B7" ); + x->setId( PLAYER_ID ); + x->setColiderColor( "00FF00" ); + scene.addObject( x ); player = x; - auto z = std::make_shared(0,2.5,0,0,r); - auto z_col = SDLPP::Rect(-1,0,-1,-1); + auto z = std::make_shared< SDLPP::RectangleRender >( 0, 2.5, 0, 0, r ); + auto z_col = SDLPP::Rect( -1, 0, -1, -1 ); z_col.setInfinite(); - z->addCollision(z_col); - z->setId(DEATH); - z->setColiderColor("FF00FF"); - scene.addObject(z); - auto y = std::make_shared(0, 0, 0.2, 0.1, r); - y->setText(*font, "DEMO", "#FFFFFF", "#000000", 5); - y->setPermanent(true); - y->setId(123); - scene.addObject(y); + z->addCollision( z_col ); + z->setId( DEATH ); + z->setColiderColor( "FF00FF" ); + scene.addObject( z ); + auto y = std::make_shared< SDLPP::TextRenderer >( 0, 0, 0.2, 0.1, r ); + y->setText( *font, "DEMO", "#FFFFFF", "#000000", 5 ); + y->setPermanent( true ); + y->setId( 123 ); + scene.addObject( y ); } -void addPause(SDLPP::Scene &scene, std::shared_ptr &r) { - auto bg = std::make_shared(0,0,10,10,r,"#00000080", true); - bg->setId(123); - bg->setPermanent(true); - scene.addObject(bg); - auto y = std::make_shared(0.25, 0.1, 0.5, 0.3, r); - y->setText(*font, "PAUSED", "#FFFFFF", "#000000", 5); - y->setId(0); +void addPause( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer > &r ) { + auto bg = std::make_shared< SDLPP::RectangleRender >( 0, 0, 10, 10, r, + "#00000080", true ); + bg->setId( 123 ); + bg->setPermanent( true ); + scene.addObject( bg ); + auto y = std::make_shared< SDLPP::TextRenderer >( 0.25, 0.1, 0.5, 0.3, r ); + y->setText( *font, "PAUSED", "#FFFFFF", "#000000", 5 ); + y->setId( 0 ); y->centerX(); - scene.addObject(y); - auto resume = std::make_shared(0.4, 0.5, 0.2, 0.1, r); - resume->setText(*font, "Resume", "#FFFFFF", "#000000", 5); - resume->setColor("#FFFFFF40"); + scene.addObject( y ); + auto resume = + std::make_shared< SDLPP::TextRenderer >( 0.4, 0.5, 0.2, 0.1, r ); + resume->setText( *font, "Resume", "#FFFFFF", "#000000", 5 ); + resume->setColor( "#FFFFFF40" ); resume->centerX(); - scene.addObject(resume); - pause_options.push_back(resume); - auto quit = std::make_shared(0.4, 0.7, 0.2, 0.1, r); - quit->setText(*font, "Quit Game", "#FFFFFF", "#000000", 5); + scene.addObject( resume ); + pause_options.push_back( resume ); + auto quit = + std::make_shared< SDLPP::TextRenderer >( 0.4, 0.7, 0.2, 0.1, r ); + quit->setText( *font, "Quit Game", "#FFFFFF", "#000000", 5 ); quit->centerX(); - scene.addObject(quit); - pause_options.push_back(quit); + scene.addObject( quit ); + pause_options.push_back( quit ); } void quitGame() { @@ -180,232 +197,236 @@ void quitGame() { quit = true; } -void handleKeyDown(SDL_Keycode key, SDLPP::Scene &scene) { - switch(key) { - case SDLK_ESCAPE: { - pause = true; - pause_scene->updateSizeAndPosition(); - player->resetMovementX(); - std::thread pauseThread(doInputPause); - pauseThread.detach(); - } - break; - case SDLK_a: - player->addMovement(-1,0); - break; - case SDLK_d: - player->addMovement(1,0); - break; - case SDLK_SPACE: - case SDLK_w: - if(!player->isJumping() && !pause) { - player->setLastStand(); - player->jump(); - } - break; - case SDLK_s: - break; - case SDLK_r: - scene.getRenderer().setRenderColiders(!scene.getRenderer().getRenderColiders()); - default: - break; +void handleKeyDown( SDL_Keycode key, SDLPP::Scene &scene ) { + switch ( key ) { + case SDLK_ESCAPE: { + pause = true; + pause_scene->updateSizeAndPosition(); + player->resetMovementX(); + std::thread pauseThread( doInputPause ); + pauseThread.detach(); + } break; + case SDLK_a: + player->addMovement( -1, 0 ); + break; + case SDLK_d: + player->addMovement( 1, 0 ); + break; + case SDLK_SPACE: + case SDLK_w: + if ( !player->isJumping() && !pause ) { + player->setLastStand(); + player->jump(); + } + break; + case SDLK_s: + break; + case SDLK_r: + scene.getRenderer().setRenderColiders( + !scene.getRenderer().getRenderColiders() ); + default: + break; } } -void handleKeyDownPause(SDL_Keycode key) { - switch(key) { - case SDLK_ESCAPE: { - pause = false; - active_scene->setPrevTicks(SDL_GetTicks()); - std::thread inputThread(doInput, active_scene); - inputThread.detach(); - } - break; - case SDLK_r: - active_scene->getRenderer().setRenderColiders(!active_scene->getRenderer().getRenderColiders()); - break; - case SDLK_s: - case SDLK_DOWN: - pause_options[pause_select]->unsetColor(); - pause_select++; - if(pause_select > pause_max) - pause_select = 0; - pause_options[pause_select]->setColor("FFFFFF40"); - break; - case SDLK_w: - case SDLK_UP: - pause_options[pause_select]->unsetColor(); - pause_select--; - if(pause_select < 0) - pause_select = pause_max; - pause_options[pause_select]->setColor("FFFFFF40"); - break; - case SDLK_RETURN: - switch(pause_select) { - case 0:{ - pause = false; - active_scene->setPrevTicks(SDL_GetTicks()); - std::thread inputThread(doInput, active_scene); - inputThread.detach(); - } - break; - case 1: - quitGame(); - default: - break; - } +void handleKeyDownPause( SDL_Keycode key ) { + switch ( key ) { + case SDLK_ESCAPE: { + pause = false; + active_scene->setPrevTicks( SDL_GetTicks() ); + std::thread inputThread( doInput, active_scene ); + inputThread.detach(); + } break; + case SDLK_r: + active_scene->getRenderer().setRenderColiders( + !active_scene->getRenderer().getRenderColiders() ); + break; + case SDLK_s: + case SDLK_DOWN: + pause_options[pause_select]->unsetColor(); + pause_select++; + if ( pause_select > pause_max ) + pause_select = 0; + pause_options[pause_select]->setColor( "FFFFFF40" ); + break; + case SDLK_w: + case SDLK_UP: + pause_options[pause_select]->unsetColor(); + pause_select--; + if ( pause_select < 0 ) + pause_select = pause_max; + pause_options[pause_select]->setColor( "FFFFFF40" ); + break; + case SDLK_RETURN: + switch ( pause_select ) { + case 0: { + pause = false; + active_scene->setPrevTicks( SDL_GetTicks() ); + std::thread inputThread( doInput, active_scene ); + inputThread.detach(); + } break; + case 1: + quitGame(); default: break; + } + default: + break; } } -void handleKeyUp(SDL_Keycode key) { - switch(key) { - case SDLK_a: - player->addMovement(1,0); - break; - case SDLK_d: - player->addMovement(-1,0); - break; - case SDLK_w: - case SDLK_s: - default: - break; +void handleKeyUp( SDL_Keycode key ) { + switch ( key ) { + case SDLK_a: + player->addMovement( 1, 0 ); + break; + case SDLK_d: + player->addMovement( -1, 0 ); + break; + case SDLK_w: + case SDLK_s: + default: + break; } } -void pollEvents(SDLPP::Scene &scene) { +void pollEvents( SDLPP::Scene &scene ) { SDL_Event event; - while( SDL_PollEvent( &event ) != 0 ) { - switch(event.type) { - case SDL_QUIT: - quitGame(); - break; - case SDL_KEYDOWN: - if( !event.key.repeat ) - handleKeyDown(event.key.keysym.sym, scene); - break; - case SDL_KEYUP: - handleKeyUp(event.key.keysym.sym); - break; - case SDL_WINDOWEVENT: - if(event.window.event == SDL_WINDOWEVENT_RESIZED) - scene.updateSizeAndPosition(); - default: - break; + while ( SDL_PollEvent( &event ) != 0 ) { + switch ( event.type ) { + case SDL_QUIT: + quitGame(); + break; + case SDL_KEYDOWN: + if ( !event.key.repeat ) + handleKeyDown( event.key.keysym.sym, scene ); + break; + case SDL_KEYUP: + handleKeyUp( event.key.keysym.sym ); + break; + case SDL_WINDOWEVENT: + if ( event.window.event == SDL_WINDOWEVENT_RESIZED ) + scene.updateSizeAndPosition(); + default: + break; } } } void pollEventsPause() { SDL_Event event; - while( SDL_PollEvent( &event ) != 0 ) { - switch(event.type) { - case SDL_QUIT: - quitGame(); - break; - case SDL_KEYDOWN: - if( !event.key.repeat ) - handleKeyDownPause(event.key.keysym.sym); - break; - case SDL_WINDOWEVENT: - if(event.window.event == SDL_WINDOWEVENT_RESIZED) { - active_scene->updateSizeAndPosition(); - pause_scene->updateSizeAndPosition(); - } - default: - break; + while ( SDL_PollEvent( &event ) != 0 ) { + switch ( event.type ) { + case SDL_QUIT: + quitGame(); + break; + case SDL_KEYDOWN: + if ( !event.key.repeat ) + handleKeyDownPause( event.key.keysym.sym ); + break; + case SDL_WINDOWEVENT: + if ( event.window.event == SDL_WINDOWEVENT_RESIZED ) { + active_scene->updateSizeAndPosition(); + pause_scene->updateSizeAndPosition(); + } + default: + break; } } } -void doInput(std::shared_ptr scene) { +void doInput( std::shared_ptr< SDLPP::Scene > scene ) { FPSmanager gFPS; - SDL_initFramerate(&gFPS); - SDL_setFramerate(&gFPS, 200); - while(!quit && !pause) { - SDL_framerateDelay(&gFPS); - pollEvents(*scene); + SDL_initFramerate( &gFPS ); + SDL_setFramerate( &gFPS, 200 ); + while ( !quit && !pause ) { + SDL_framerateDelay( &gFPS ); + pollEvents( *scene ); scene->movement(); bool gravity = true; - for( auto &x : scene->getCollisions(*player) ) { - if( x->getId() == STONE_ID ) { + for ( auto &x : scene->getCollisions( *player ) ) { + if ( x->getId() == STONE_ID ) { gravity = false; - if(player->isGravityEnabled()) { + if ( player->isGravityEnabled() ) { auto stoneRect = x->getDoubleRect(); auto playerPos = player->getDoubleRect(); auto newPX = playerPos.first.first; - auto newPY = stoneRect.first.second - playerPos.second.second; - player->setPos(newPX, newPY); + auto newPY = + stoneRect.first.second - playerPos.second.second; + player->setPos( newPX, newPY ); player->setLastStand(); } - x->specialAction(DESTROYABLE_DESTROY); + x->specialAction( DESTROYABLE_DESTROY ); } - if( x->getId() == DEATH ) { + if ( x->getId() == DEATH ) { std::cout << "Oh no, you died!" << std::endl; quitGame(); } } - player->setGravity(gravity); + player->setGravity( gravity ); auto playerX = player->getRect().x; auto width = scene->getWidth(); auto rightBarrier = width * 0.7; auto leftBarrier = width * 0.3; - auto rightmostX = scene->rightmost()->getRect().x + scene->rightmost()->getRect().w; + auto rightmostX = + scene->rightmost()->getRect().x + scene->rightmost()->getRect().w; auto leftmostX = scene->leftmost()->getRect().x; scene->moveEverything( - (playerX > rightBarrier && rightmostX > width) * (rightBarrier - playerX)/width, 0); - scene->moveEverything( - (playerX < leftBarrier && leftmostX < 0) * (leftBarrier - playerX)/width, 0); + ( playerX > rightBarrier && rightmostX > width ) * + ( rightBarrier - playerX ) / width, + 0 ); + scene->moveEverything( ( playerX < leftBarrier && leftmostX < 0 ) * + ( leftBarrier - playerX ) / width, + 0 ); } } void doInputPause() { FPSmanager gFPS; - SDL_initFramerate(&gFPS); - SDL_setFramerate(&gFPS, 200); - while(pause) { - SDL_framerateDelay(&gFPS); + SDL_initFramerate( &gFPS ); + SDL_setFramerate( &gFPS, 200 ); + while ( pause ) { + SDL_framerateDelay( &gFPS ); pollEventsPause(); - if(!pause) + if ( !pause ) break; } } int main() { SDLPP::init(); - SDLPP::Window w("Oh yeah, boi!"); - auto renderer = std::make_shared(w); - renderer->setBlendMode(SDL_BLENDMODE_BLEND); - auto main_scene = std::make_shared(renderer); + SDLPP::Window w( "Oh yeah, boi!" ); + auto renderer = std::make_shared< SDLPP::Renderer >( w ); + renderer->setBlendMode( SDL_BLENDMODE_BLEND ); + auto main_scene = std::make_shared< SDLPP::Scene >( renderer ); active_scene = main_scene; - font = std::make_shared("testfont.ttf", 96); - addStuff(*main_scene, renderer); - player->setMovementSpeed(0.3); + font = std::make_shared< SDLPP::Font >( "testfont.ttf", 96 ); + addStuff( *main_scene, renderer ); + player->setMovementSpeed( 0.3 ); player->enableGravity(); - pause_scene = std::make_shared(renderer); - addPause(*pause_scene, renderer); + pause_scene = std::make_shared< SDLPP::Scene >( renderer ); + addPause( *pause_scene, renderer ); int base = SDL_GetTicks(); int frames = 0; FPSmanager gFPS; - SDL_initFramerate(&gFPS); - SDL_setFramerate(&gFPS, 60); - std::thread inputThread(doInput, main_scene); + SDL_initFramerate( &gFPS ); + SDL_setFramerate( &gFPS, 60 ); + std::thread inputThread( doInput, main_scene ); inputThread.detach(); - while( !quit ) { -// SDL_framerateDelay(&gFPS); + while ( !quit ) { + // SDL_framerateDelay(&gFPS); main_scene->renderScene(); - if(pause) { - pause_scene->renderScene(false); + if ( pause ) { + pause_scene->renderScene( false ); } main_scene->presentScene(); frames++; - if(SDL_GetTicks() - base >= 1000) { + if ( SDL_GetTicks() - base >= 1000 ) { base = SDL_GetTicks(); - printf("FPS: %d\n", frames); + printf( "FPS: %d\n", frames ); frames = 0; } } diff --git a/sdlpp.cpp b/sdlpp.cpp index 2a4ec99..9ddbe6b 100644 --- a/sdlpp.cpp +++ b/sdlpp.cpp @@ -4,165 +4,186 @@ #include bool SDLPP::init() { - if( SDL_Init(SDL_INIT_VIDEO) < 0 ) { - std::cerr << "SDL could not initialize! SDL_Error: " << SDL_GetError() << std::endl; + if ( SDL_Init( SDL_INIT_VIDEO ) < 0 ) { + std::cerr << "SDL could not initialize! SDL_Error: " << SDL_GetError() + << std::endl; return false; } - if( IMG_Init( IMG_INIT_PNG ) != IMG_INIT_PNG ) { - std::cerr << "SDL_image could not initialize! SDL_image Error: " << IMG_GetError() << std::endl; + if ( IMG_Init( IMG_INIT_PNG ) != IMG_INIT_PNG ) { + std::cerr << "SDL_image could not initialize! SDL_image Error: " + << IMG_GetError() << std::endl; return false; } - if( TTF_Init() == -1 ) { - std::cerr << "SDL_ttf could not initialize! SDL_ttf Error: " << TTF_GetError() << std::endl; + if ( TTF_Init() == -1 ) { + std::cerr << "SDL_ttf could not initialize! SDL_ttf Error: " + << TTF_GetError() << std::endl; return false; } return true; } -bool SDLPP::init(uint32_t SDL_OPTIONS) { - if( SDL_Init(SDL_OPTIONS) < 0 ) { - std::cerr << "SDL could not initialize! SDL_Error: " << SDL_GetError() << std::endl; +bool SDLPP::init( uint32_t SDL_OPTIONS ) { + if ( SDL_Init( SDL_OPTIONS ) < 0 ) { + std::cerr << "SDL could not initialize! SDL_Error: " << SDL_GetError() + << std::endl; return false; } - if( IMG_Init( IMG_INIT_PNG ) != IMG_INIT_PNG ) { - std::cerr << "SDL_image could not initialize! SDL_image Error: " << IMG_GetError() << std::endl; + if ( IMG_Init( IMG_INIT_PNG ) != IMG_INIT_PNG ) { + std::cerr << "SDL_image could not initialize! SDL_image Error: " + << IMG_GetError() << std::endl; return false; } return true; } -bool SDLPP::init(uint32_t SDL_OPTIONS, int IMAGE_OPTIONS) { - if( SDL_Init(SDL_OPTIONS) < 0 ) { - std::cerr << "SDL could not initialize! SDL_Error: " << SDL_GetError() << std::endl; +bool SDLPP::init( uint32_t SDL_OPTIONS, int IMAGE_OPTIONS ) { + if ( SDL_Init( SDL_OPTIONS ) < 0 ) { + std::cerr << "SDL could not initialize! SDL_Error: " << SDL_GetError() + << std::endl; return false; } - if( IMG_Init( IMAGE_OPTIONS ) != IMAGE_OPTIONS ) { - std::cerr << "SDL_image could not initialize! SDL_image Error: " << IMG_GetError() << std::endl; + if ( IMG_Init( IMAGE_OPTIONS ) != IMAGE_OPTIONS ) { + std::cerr << "SDL_image could not initialize! SDL_image Error: " + << IMG_GetError() << std::endl; return false; } return true; } void SDLPP::CircleRender::render() { - std::cout << "I'm a circle, look at me go!" << std::endl << "My dimensions are: [" << x_ << ", " << y_ << "], radius: " << rad_ << std::endl; + std::cout << "I'm a circle, look at me go!" << std::endl + << "My dimensions are: [" << x_ << ", " << y_ + << "], radius: " << rad_ << std::endl; } // only rectangles for now -bool intersects(const SDLPP::CollisionPolygon &p1, const SDLPP::CollisionPolygon &p2) { - return !(p1.rightmost() < p2.leftmost() || p2.rightmost() < p1.leftmost() || - p1.topmost() > p2.bottommost() || p2.topmost() > p1.bottommost()); +bool intersects( const SDLPP::CollisionPolygon &p1, + const SDLPP::CollisionPolygon &p2 ) { + return !( + p1.rightmost() < p2.leftmost() || p2.rightmost() < p1.leftmost() || + p1.topmost() > p2.bottommost() || p2.topmost() > p1.bottommost() ); } -bool infinityIntersection(const SDLPP::CollisionPolygon &infinite, const SDLPP::CollisionPolygon &other) { +bool infinityIntersection( const SDLPP::CollisionPolygon &infinite, + const SDLPP::CollisionPolygon &other ) { int ileft = infinite.leftmost(); int iright = infinite.rightmost(); int itop = infinite.topmost(); int ibottom = infinite.bottommost(); - bool ret = ileft != -1 && ileft <= other.rightmost() && ileft >= other.leftmost(); - ret |= iright != -1 && iright >= other.leftmost() && iright <= other.rightmost(); + bool ret = + ileft != -1 && ileft <= other.rightmost() && ileft >= other.leftmost(); + ret |= iright != -1 && iright >= other.leftmost() && + iright <= other.rightmost(); ret |= itop != -1 && itop <= other.bottommost() && itop >= other.topmost(); - ret |= ibottom != -1 && ibottom >= other.topmost() && ibottom <= other.bottommost(); + ret |= ibottom != -1 && ibottom >= other.topmost() && + ibottom <= other.bottommost(); ret |= ileft == -1 && iright == -1 && itop == -1 && ibottom == -1; return ret; } -bool SDLPP::Rect::colidesWith(const SDLPP::CollisionPolygon &other) const { - if(other.isCircle()) { - return other.colidesWith(*this); +bool SDLPP::Rect::colidesWith( const SDLPP::CollisionPolygon &other ) const { + if ( other.isCircle() ) { + return other.colidesWith( *this ); } - if(other.isInfinite() ) { - return infinityIntersection(other, *this); + if ( other.isInfinite() ) { + return infinityIntersection( other, *this ); } - if(isInfinite()) - return infinityIntersection(*this, other); - return intersects(*this, other); + if ( isInfinite() ) + return infinityIntersection( *this, other ); + return intersects( *this, other ); } -bool SDLPP::Circle::colidesWith(const SDLPP::CollisionPolygon &other) const { - if(other.isCircle()) { - int otherRad = (other.rightmost() - other.leftmost())/2; +bool SDLPP::Circle::colidesWith( const SDLPP::CollisionPolygon &other ) const { + if ( other.isCircle() ) { + int otherRad = ( other.rightmost() - other.leftmost() ) / 2; int thisRad = getRadius(); int totalDist = otherRad + thisRad; - int xdiff = other.leftmost() + otherRad - (leftmost() + thisRad); - int ydiff = other.topmost() + otherRad - (topmost() + thisRad); - return (xdiff*xdiff + ydiff*ydiff) <= totalDist * totalDist; - } else if (other.isInfinite()) { - return infinityIntersection(other, *this); + int xdiff = other.leftmost() + otherRad - ( leftmost() + thisRad ); + int ydiff = other.topmost() + otherRad - ( topmost() + thisRad ); + return ( xdiff * xdiff + ydiff * ydiff ) <= totalDist * totalDist; + } else if ( other.isInfinite() ) { + return infinityIntersection( other, *this ); } int rad = rad_; int centerx = getX(); int centery = getY(); - if(other.topmost() <= centery && other.bottommost() >= centery) { - return other.leftmost() <= rightmost() && other.rightmost() >= leftmost(); - } else if (other.leftmost() <= centerx && other.rightmost() >= centerx) { - return other.topmost() <= bottommost() && other.bottommost() >= topmost(); + if ( other.topmost() <= centery && other.bottommost() >= centery ) { + return other.leftmost() <= rightmost() && + other.rightmost() >= leftmost(); + } else if ( other.leftmost() <= centerx && other.rightmost() >= centerx ) { + return other.topmost() <= bottommost() && + other.bottommost() >= topmost(); } - int pointx=0, pointy=0; - if(centerx > other.rightmost()) { + int pointx = 0, pointy = 0; + if ( centerx > other.rightmost() ) { pointx = other.rightmost(); } else { pointx = other.leftmost(); } - if(centery < other.topmost()) { + if ( centery < other.topmost() ) { pointy = other.topmost(); } else { pointy = other.bottommost(); } - int distancesquared = (pointx - centerx)*(pointx - centerx) + (pointy - centery)*(pointy-centery); - return distancesquared <= rad*rad; + int distancesquared = ( pointx - centerx ) * ( pointx - centerx ) + + ( pointy - centery ) * ( pointy - centery ); + return distancesquared <= rad * rad; } -int SDLPP::hex2num(char c) { - if(c <= '9') +int SDLPP::hex2num( char c ) { + if ( c <= '9' ) return c - '0'; - switch(c) { - case 'a': - case 'A': - return 10; - case 'b': - case 'B': - return 11; - case 'c': - case 'C': - return 12; - case 'd': - case 'D': - return 13; - case 'e': - case 'E': - return 14; - default: - return 15; + switch ( c ) { + case 'a': + case 'A': + return 10; + case 'b': + case 'B': + return 11; + case 'c': + case 'C': + return 12; + case 'd': + case 'D': + return 13; + case 'e': + case 'E': + return 14; + default: + return 15; } } -std::tuple SDLPP::getColorsHEX(const std::string &color) { +std::tuple< int, int, int, int > +SDLPP::getColorsHEX( const std::string &color ) { int red = 0, green = 0, blue = 0, alpha = 255; const char *color_ptr = color.c_str(); - if(color_ptr[0] == '#') + if ( color_ptr[0] == '#' ) color_ptr++; - red = hex2num(color_ptr[0])*16 + hex2num(color_ptr[1]); - green = hex2num(color_ptr[2])*16 + hex2num(color_ptr[3]); - blue = hex2num(color_ptr[4])*16 + hex2num(color_ptr[5]); - if( color_ptr[6] != '\0' ) - alpha = hex2num(color_ptr[6])*16 + hex2num(color_ptr[7]); - return {red, green, blue, alpha}; + red = hex2num( color_ptr[0] ) * 16 + hex2num( color_ptr[1] ); + green = hex2num( color_ptr[2] ) * 16 + hex2num( color_ptr[3] ); + blue = hex2num( color_ptr[4] ) * 16 + hex2num( color_ptr[5] ); + if ( color_ptr[6] != '\0' ) + alpha = hex2num( color_ptr[6] ) * 16 + hex2num( color_ptr[7] ); + return { red, green, blue, alpha }; } -SDL_Color SDLPP::getSDLColorTuple(const std::tuple &tuple) { +SDL_Color +SDLPP::getSDLColorTuple( const std::tuple< int, int, int, int > &tuple ) { SDL_Color ret_color{}; - ret_color.r = std::get<0>(tuple); - ret_color.g = std::get<1>(tuple); - ret_color.b = std::get<2>(tuple); - ret_color.a = std::get<3>(tuple); + ret_color.r = std::get< 0 >( tuple ); + ret_color.g = std::get< 1 >( tuple ); + ret_color.b = std::get< 2 >( tuple ); + ret_color.a = std::get< 3 >( tuple ); return ret_color; } -SDL_Color SDLPP::getSDLColorHEX(const std::string &color) { - auto color_tuple = SDLPP::getColorsHEX(color); - return getSDLColorTuple(color_tuple); +SDL_Color SDLPP::getSDLColorHEX( const std::string &color ) { + auto color_tuple = SDLPP::getColorsHEX( color ); + return getSDLColorTuple( color_tuple ); } -std::tuple SDLPP::getColorsSDLColor(const SDL_Color &color) { - return {color.r, color.g, color.b, color.a}; +std::tuple< int, int, int, int > +SDLPP::getColorsSDLColor( const SDL_Color &color ) { + return { color.r, color.g, color.b, color.a }; } diff --git a/sdlpp.hpp b/sdlpp.hpp index 3e214c5..0243904 100644 --- a/sdlpp.hpp +++ b/sdlpp.hpp @@ -21,34 +21,41 @@ namespace SDLPP { -int hex2num(char c); +int hex2num( char c ); -std::tuple getColorsHEX(const std::string &color); -SDL_Color getSDLColorHEX(const std::string &color); -std::tuple getColorsSDLColor(const SDL_Color &color); -SDL_Color getSDLColorTuple(const std::tuple &tuple); +std::tuple< int, int, int, int > getColorsHEX( const std::string &color ); +SDL_Color getSDLColorHEX( const std::string &color ); +std::tuple< int, int, int, int > getColorsSDLColor( const SDL_Color &color ); +SDL_Color getSDLColorTuple( const std::tuple< int, int, int, int > &tuple ); class Window { public: - Window() : Window("SDL Window", 640, 480, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED) { - } - Window(const std::string &window_name) : Window(window_name, 640, 480, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED) { - } - Window(const std::string &window_name, uint32_t width, uint32_t height) : Window(window_name, width, height, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED) {} - Window(const std::string &window_name, uint32_t width, uint32_t height, - uint32_t posx, uint32_t posy) { - window = SDL_CreateWindow(window_name.c_str(), posx, posy, width, height, SDL_WINDOW_SHOWN); - if( window == NULL ) { - std::cerr << "SDL could not create a window! SDL_Error: " << SDL_GetError() << std::endl; + Window() + : Window( "SDL Window", 640, 480, SDL_WINDOWPOS_UNDEFINED, + SDL_WINDOWPOS_UNDEFINED ) {} + Window( const std::string &window_name ) + : Window( window_name, 640, 480, SDL_WINDOWPOS_UNDEFINED, + SDL_WINDOWPOS_UNDEFINED ) {} + Window( const std::string &window_name, uint32_t width, uint32_t height ) + : Window( window_name, width, height, SDL_WINDOWPOS_UNDEFINED, + SDL_WINDOWPOS_UNDEFINED ) {} + Window( const std::string &window_name, uint32_t width, uint32_t height, + uint32_t posx, uint32_t posy ) { + window = SDL_CreateWindow( window_name.c_str(), posx, posy, width, + height, SDL_WINDOW_SHOWN ); + if ( window == NULL ) { + std::cerr << "SDL could not create a window! SDL_Error: " + << SDL_GetError() << std::endl; throw "Couldn't create window"; } } ~Window() { - SDL_DestroyWindow(window); + SDL_DestroyWindow( window ); } SDL_Window *getWindowPtr() { return window; } + private: SDL_Window *window = NULL; }; @@ -56,24 +63,26 @@ private: class Renderer { public: Renderer() = delete; - Renderer(Window &window) { - renderer = SDL_CreateRenderer(window.getWindowPtr(), -1, SDL_RENDERER_ACCELERATED); - if(renderer == NULL ) { - std::cerr << "SDL could not create a renderer! SDL_Error: " << SDL_GetError(); + Renderer( Window &window ) { + renderer = SDL_CreateRenderer( window.getWindowPtr(), -1, + SDL_RENDERER_ACCELERATED ); + if ( renderer == NULL ) { + std::cerr << "SDL could not create a renderer! SDL_Error: " + << SDL_GetError(); throw "Couldn't create renderer"; } - SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF); + SDL_SetRenderDrawColor( renderer, 0xFF, 0xFF, 0xFF, 0xFF ); } ~Renderer() { - SDL_DestroyRenderer(renderer); + SDL_DestroyRenderer( renderer ); } SDL_Renderer *getRendererPtr() { return renderer; } - std::pair getDimensions() const { + std::pair< int, int > getDimensions() const { int width = 0, height = 0; - SDL_GetRendererOutputSize(renderer, &width, &height); - return {width, height}; + SDL_GetRendererOutputSize( renderer, &width, &height ); + return { width, height }; } int getWidth() const { return getDimensions().first; @@ -83,21 +92,24 @@ public: } int getSmallerSide() const { auto dimensions = getDimensions(); - return dimensions.first < dimensions.second ? dimensions.first : dimensions.second; + return dimensions.first < dimensions.second ? dimensions.first + : dimensions.second; } int getLargerSide() const { auto dimensions = getDimensions(); - return dimensions.first > dimensions.second ? dimensions.first : dimensions.second; + return dimensions.first > dimensions.second ? dimensions.first + : dimensions.second; } - void setBlendMode(SDL_BlendMode blendMode) { - SDL_SetRenderDrawBlendMode(renderer, blendMode); + void setBlendMode( SDL_BlendMode blendMode ) { + SDL_SetRenderDrawBlendMode( renderer, blendMode ); } - void setRenderColiders(bool render) { + void setRenderColiders( bool render ) { render_coliders = render; } bool getRenderColiders() { return render_coliders; } + private: SDL_Renderer *renderer = NULL; bool render_coliders = false; @@ -106,10 +118,11 @@ private: class Font { public: Font() = delete; - Font(const std::string &font, int size) { - font_ptr = TTF_OpenFont(font.c_str(), size); - if(font_ptr == NULL) { - std::cerr << "Unable to load font '" << font << "': TTF Error: " << TTF_GetError() << std::endl; + Font( const std::string &font, int size ) { + font_ptr = TTF_OpenFont( font.c_str(), size ); + if ( font_ptr == NULL ) { + std::cerr << "Unable to load font '" << font + << "': TTF Error: " << TTF_GetError() << std::endl; throw "TTF_OpenFont error"; } } @@ -122,18 +135,19 @@ public: TTF_Font *getFont() { return font_ptr; } - void setOutline(int size) { - TTF_SetFontOutline(font_ptr, size); + void setOutline( int size ) { + TTF_SetFontOutline( font_ptr, size ); } int getOutline() { - return TTF_GetFontOutline(font_ptr); + return TTF_GetFontOutline( font_ptr ); } - void setStyle(int style) { - TTF_SetFontStyle(font_ptr, style); + void setStyle( int style ) { + TTF_SetFontStyle( font_ptr, style ); } - void setHinting(int hinting) { - TTF_SetFontHinting(font_ptr, hinting); + void setHinting( int hinting ) { + TTF_SetFontHinting( font_ptr, hinting ); } + private: TTF_Font *font_ptr; }; @@ -141,117 +155,142 @@ private: class Texture { public: Texture() = delete; - Texture(std::shared_ptr &renderer, const std::string &img_path) : Texture(renderer, img_path, "") {} - Texture(std::shared_ptr &renderer, const std::string &img_path, const std::string &color_key) { - SDL_Surface *surface = IMG_Load(img_path.c_str()); - if( surface == NULL ) { - std::cerr << "Unable to load image '" << img_path << "': IMG Error: " << IMG_GetError() << std::endl; + Texture( std::shared_ptr< Renderer > &renderer, + const std::string &img_path ) + : Texture( renderer, img_path, "" ) {} + Texture( std::shared_ptr< Renderer > &renderer, const std::string &img_path, + const std::string &color_key ) { + SDL_Surface *surface = IMG_Load( img_path.c_str() ); + if ( surface == NULL ) { + std::cerr << "Unable to load image '" << img_path + << "': IMG Error: " << IMG_GetError() << std::endl; throw "IMG_Load error"; } - if( !color_key.empty() ) { - auto colors = getColorsHEX(color_key); - SDL_SetColorKey(surface, SDL_TRUE, SDL_MapRGB(surface->format, std::get<0>(colors), std::get<1>(colors), std::get<2>(colors))); + if ( !color_key.empty() ) { + auto colors = getColorsHEX( color_key ); + SDL_SetColorKey( surface, SDL_TRUE, + SDL_MapRGB( surface->format, + std::get< 0 >( colors ), + std::get< 1 >( colors ), + std::get< 2 >( colors ) ) ); } - setTextureFromSurface(renderer, surface); + setTextureFromSurface( renderer, surface ); } - Texture(std::shared_ptr &renderer, Font &font, const std::string &text, const std::string &color = "FFFFFF", const std::string &outline_color = "000000", const int outline_size = -1) { - if(outline_size != -1) { - font.setOutline(outline_size); + Texture( std::shared_ptr< Renderer > &renderer, Font &font, + const std::string &text, const std::string &color = "FFFFFF", + const std::string &outline_color = "000000", + const int outline_size = -1 ) { + if ( outline_size != -1 ) { + font.setOutline( outline_size ); } int og_outline = 0; SDL_Surface *bg_surface = NULL; - if((og_outline = font.getOutline()) != 0) { - bg_surface = TTF_RenderUTF8_Blended( font.getFont(), text.c_str(), getSDLColorHEX(outline_color) ); - if( bg_surface == NULL ) { - std::cerr << "Unable to render text '" << text << "': TTF Error: " << TTF_GetError() << std::endl; + if ( ( og_outline = font.getOutline() ) != 0 ) { + bg_surface = TTF_RenderUTF8_Blended( + font.getFont(), text.c_str(), getSDLColorHEX( outline_color ) ); + if ( bg_surface == NULL ) { + std::cerr << "Unable to render text '" << text + << "': TTF Error: " << TTF_GetError() << std::endl; throw "TTF_RenderUTF8_Shaded error"; } - font.setOutline(0); + font.setOutline( 0 ); } - SDL_Surface *surface = TTF_RenderUTF8_Blended( font.getFont(), text.c_str(), getSDLColorHEX(color) ); - if( surface == NULL ) { - std::cerr << "Unable to render text '" << text << "': TTF Error: " << TTF_GetError() << std::endl; + SDL_Surface *surface = TTF_RenderUTF8_Blended( + font.getFont(), text.c_str(), getSDLColorHEX( color ) ); + if ( surface == NULL ) { + std::cerr << "Unable to render text '" << text + << "': TTF Error: " << TTF_GetError() << std::endl; throw "TTF_RenderUTF8_Shaded error"; } - if(og_outline != 0) { - SDL_Rect rect = {og_outline, og_outline, surface->w, surface->h}; - SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND); - SDL_BlitSurface(surface, NULL, bg_surface, &rect); - SDL_FreeSurface(surface); + if ( og_outline != 0 ) { + SDL_Rect rect = { og_outline, og_outline, surface->w, surface->h }; + SDL_SetSurfaceBlendMode( surface, SDL_BLENDMODE_BLEND ); + SDL_BlitSurface( surface, NULL, bg_surface, &rect ); + SDL_FreeSurface( surface ); surface = bg_surface; bg_surface = NULL; - font.setOutline(og_outline); + font.setOutline( og_outline ); } - setTextureFromSurface(renderer, surface); + setTextureFromSurface( renderer, surface ); } ~Texture() { - SDL_DestroyTexture(texture); + SDL_DestroyTexture( texture ); } SDL_Texture *getTexturePtr() { return texture; } + private: - void setTextureFromSurface(std::shared_ptr &renderer, SDL_Surface *surface) { - texture = SDL_CreateTextureFromSurface(renderer->getRendererPtr(), surface); - if( texture == NULL ) { - std::cerr << "Unable to create texture from surface! SDL Error: " << SDL_GetError() << std::endl; + void setTextureFromSurface( std::shared_ptr< Renderer > &renderer, + SDL_Surface *surface ) { + texture = + SDL_CreateTextureFromSurface( renderer->getRendererPtr(), surface ); + if ( texture == NULL ) { + std::cerr << "Unable to create texture from surface! SDL Error: " + << SDL_GetError() << std::endl; throw "Texture error"; } - SDL_FreeSurface(surface); + SDL_FreeSurface( surface ); } SDL_Texture *texture = NULL; }; class CollisionPolygon { public: - CollisionPolygon(double x, double y) { + CollisionPolygon( double x, double y ) { original_x = x; original_y = y; position_x = 0; position_y = 0; } virtual ~CollisionPolygon() {} - virtual bool colidesWith(const CollisionPolygon &other) const = 0; + virtual bool colidesWith( const CollisionPolygon &other ) const = 0; virtual bool isCircle() const = 0; - virtual bool isInfinite() const { return infinite; } - virtual void setInfinite() { infinite = true; } + virtual bool isInfinite() const { + return infinite; + } + virtual void setInfinite() { + infinite = true; + } virtual int topmost() const = 0; virtual int bottommost() const = 0; virtual int leftmost() const = 0; virtual int rightmost() const = 0; - virtual void updateCollision(int x, int y, int w, int h) { + virtual void updateCollision( int x, int y, int w, int h ) { position_x = original_x * w + x; position_y = original_y * h + y; } - virtual void render(Renderer &renderer, const std::tuple &color) = 0; - virtual void render(Renderer &renderer) = 0; + virtual void render( Renderer &renderer, + const std::tuple< int, int, int, int > &color ) = 0; + virtual void render( Renderer &renderer ) = 0; int getX() const { return position_x; } int getY() const { return position_y; } - void setColor(const std::string &color) { - sdl_color = getSDLColorHEX(color); + void setColor( const std::string &color ) { + sdl_color = getSDLColorHEX( color ); } - void setOutlineColor(const std::string &color) { - sdl_outline = getSDLColorHEX(color); + void setOutlineColor( const std::string &color ) { + sdl_outline = getSDLColorHEX( color ); } + protected: double original_x; double original_y; int position_x; int position_y; bool infinite = false; - SDL_Color sdl_color = {0,0,0,0}; - SDL_Color sdl_outline = {0,0,0,0}; + SDL_Color sdl_color = { 0, 0, 0, 0 }; + SDL_Color sdl_outline = { 0, 0, 0, 0 }; }; class Scene; class RenderObject { public: - RenderObject(std::shared_ptr &r) : renderer(r) {} + RenderObject( std::shared_ptr< Renderer > &r ) : renderer( r ) {} virtual ~RenderObject() {} virtual void render() = 0; virtual int leftmost() = 0; @@ -262,44 +301,53 @@ public: virtual int collisionPushY() = 0; virtual int collisionWidth() = 0; virtual int collisionHeight() = 0; - virtual void specialAction(int code) = 0; - virtual std::pair,std::pair> getDoubleRect() = 0; - virtual void setPos(double x, double y) = 0; - virtual std::pair getPos() = 0; - bool colidesWith(const RenderObject &other) const { - if(!hasCollisions() || !other.hasCollisions() || getHidden() || other.getHidden()) { + virtual void specialAction( int code ) = 0; + virtual std::pair< std::pair< double, double >, + std::pair< double, double > > + getDoubleRect() = 0; + virtual void setPos( double x, double y ) = 0; + virtual std::pair< double, double > getPos() = 0; + bool colidesWith( const RenderObject &other ) const { + if ( !hasCollisions() || !other.hasCollisions() || getHidden() || + other.getHidden() ) { return false; } - for( const auto &x : collisions ) { - for( const auto &y : other.getCollisions() ) { - if(x->colidesWith(*y)) + for ( const auto &x : collisions ) { + for ( const auto &y : other.getCollisions() ) { + if ( x->colidesWith( *y ) ) return true; } } return false; } - template - void addCollision(const T &p) { - collisions.push_back(std::make_shared(p)); - collisions.back()->updateCollision(collisionPushX(), collisionPushY(), collisionWidth(), collisionHeight()); + template < class T > void addCollision( const T &p ) { + collisions.push_back( std::make_shared< T >( p ) ); + collisions.back()->updateCollision( collisionPushX(), collisionPushY(), + collisionWidth(), + collisionHeight() ); } bool hasCollisions() const { return !collisions.empty(); } - const std::vector> &getCollisions() const { + const std::vector< std::shared_ptr< CollisionPolygon > > & + getCollisions() const { return collisions; } - virtual void setTexture(std::shared_ptr &t) { + virtual void setTexture( std::shared_ptr< Texture > &t ) { texture = t; } - virtual void setTexture(const std::string &img_path) { - texture = std::make_shared(renderer, img_path); + virtual void setTexture( const std::string &img_path ) { + texture = std::make_shared< Texture >( renderer, img_path ); } - virtual void setTexture(Font &font, const std::string &text, const std::string &color = "FFFFFF", const std::string &outline_color = "000000", int outline_size = -1) { - texture = std::make_shared(renderer, font, text, color, outline_color, outline_size); + virtual void setTexture( Font &font, const std::string &text, + const std::string &color = "FFFFFF", + const std::string &outline_color = "000000", + int outline_size = -1 ) { + texture = std::make_shared< Texture >( renderer, font, text, color, + outline_color, outline_size ); } - virtual void setColor(const std::string &color) = 0; - virtual void setOutlineColor(const std::string &color) = 0; + virtual void setColor( const std::string &color ) = 0; + virtual void setOutlineColor( const std::string &color ) = 0; virtual void unsetTexture() { texture.reset(); } @@ -307,10 +355,10 @@ public: polygon.reset(); } // per second, relative to window width - void setMovementSpeed(double speed) { + void setMovementSpeed( double speed ) { movementSpeed = speed; } - void addMovement(int x, int y) { + void addMovement( int x, int y ) { movementDirection.first += x; movementDirection.second += y; } @@ -323,61 +371,63 @@ public: void clearColided() { colidedWith.clear(); } - void addColided(std::shared_ptr &obj) { - colidedWith.push_back(obj); + void addColided( std::shared_ptr< RenderObject > &obj ) { + colidedWith.push_back( obj ); } - std::vector> &getColidedWith() { + std::vector< std::shared_ptr< RenderObject > > &getColidedWith() { return colidedWith; } - void setId(uint64_t input_id) { + void setId( uint64_t input_id ) { id = input_id; } uint64_t getId() { return id; } - void setHidden(bool hid) { + void setHidden( bool hid ) { hidden = hid; } bool getHidden() const { return hidden; } void destroy() { - setHidden(true); + setHidden( true ); kill = true; } bool getKilled() { return kill; } - void setColiderColor(const std::string &color) { - colider_color = getColorsHEX(color); + void setColiderColor( const std::string &color ) { + colider_color = getColorsHEX( color ); } - virtual void move(int ticks) = 0; - virtual void custom_move(int ticks) = 0; + virtual void move( int ticks ) = 0; + virtual void custom_move( int ticks ) = 0; virtual void updateSizeAndPosition() = 0; virtual SDL_Rect getRect() = 0; - void setPermanent(bool perm) { + void setPermanent( bool perm ) { permanent = perm; } bool getPermanent() const { return permanent; } virtual void centerX() = 0; + protected: - std::vector> collisions; - std::shared_ptr texture; - std::shared_ptr renderer; - std::shared_ptr polygon; + std::vector< std::shared_ptr< CollisionPolygon > > collisions; + std::shared_ptr< Texture > texture; + std::shared_ptr< Renderer > renderer; + std::shared_ptr< CollisionPolygon > polygon; double movementSpeed; - std::pair movementDirection; - std::vector> colidedWith; + std::pair< int, int > movementDirection; + std::vector< std::shared_ptr< RenderObject > > colidedWith; uint64_t id; bool hidden = false; bool kill = false; - std::tuple colider_color = {0x00, 0xFF, 0xFF, 0xFF}; + std::tuple< int, int, int, int > colider_color = { 0x00, 0xFF, 0xFF, 0xFF }; uint64_t scene_id; bool permanent = false; + private: - void setSceneID(int id) { + void setSceneID( int id ) { scene_id = id; } friend Scene; @@ -385,120 +435,129 @@ private: class Scene { public: - Scene(std::shared_ptr &r) : renderer(r) { - SDL_SetRenderDrawColor(renderer->getRendererPtr(), 0xFF, 0xFF, 0xFF, 0xFF); + Scene( std::shared_ptr< Renderer > &r ) : renderer( r ) { + SDL_SetRenderDrawColor( renderer->getRendererPtr(), 0xFF, 0xFF, 0xFF, + 0xFF ); prev_ticks = SDL_GetTicks(); } - void addObject(const std::shared_ptr &obj) { + void addObject( const std::shared_ptr< RenderObject > &obj ) { render_mutex.lock(); - renderObjects.push_back(obj); - obj->setSceneID(++max_object_id); - if(obj->hasCollisions()) { - collisionObjects.push_back(obj); + renderObjects.push_back( obj ); + obj->setSceneID( ++max_object_id ); + if ( obj->hasCollisions() ) { + collisionObjects.push_back( obj ); } - if(renderObjects.size() == 1) { + if ( renderObjects.size() == 1 ) { leftmost_obj = obj; rightmost_obj = obj; } else { auto rect = obj->getDoubleRect(); auto leftmost_rect = leftmost_obj->getDoubleRect(); - if(rect.first.first < leftmost_rect.first.first) + if ( rect.first.first < leftmost_rect.first.first ) leftmost_obj = obj; auto rightmost_rect = rightmost_obj->getDoubleRect(); - if(rect.first.first + rect.second.first > rightmost_rect.first.first + rightmost_rect.second.first) + if ( rect.first.first + rect.second.first > + rightmost_rect.first.first + rightmost_rect.second.first ) rightmost_obj = obj; } render_mutex.unlock(); } - std::shared_ptr getObject(int index) { + std::shared_ptr< RenderObject > getObject( int index ) { return renderObjects[index]; } - std::vector> getObjects() { + std::vector< std::shared_ptr< RenderObject > > getObjects() { return renderObjects; } void movement() { checkKilled(); render_mutex.lock(); int now_ticks = SDL_GetTicks(); - for( const auto &x : renderObjects ) { - x->move(now_ticks - prev_ticks); + for ( const auto &x : renderObjects ) { + x->move( now_ticks - prev_ticks ); } prev_ticks = now_ticks; render_mutex.unlock(); } - std::vector> getCollisions(RenderObject &r) { - if(r.getHidden()) + std::vector< std::shared_ptr< RenderObject > > + getCollisions( RenderObject &r ) { + if ( r.getHidden() ) return {}; - std::vector> ret{}; - for(const auto &x : collisionObjects) { - if(x->colidesWith(r)) { - ret.push_back(x); + std::vector< std::shared_ptr< RenderObject > > ret{}; + for ( const auto &x : collisionObjects ) { + if ( x->colidesWith( r ) ) { + ret.push_back( x ); } } return ret; } - std::vector> getCollisions( RenderObject &r, const std::unordered_set &objectIDs ) { - if(r.getHidden()) + std::vector< std::shared_ptr< RenderObject > > + getCollisions( RenderObject &r, + const std::unordered_set< int > &objectIDs ) { + if ( r.getHidden() ) return {}; - std::vector> ret{}; - for(const auto &x : collisionObjects) { - if(objectIDs.find(x->getId()) != objectIDs.end() && x->colidesWith(r)) { - ret.push_back(x); + std::vector< std::shared_ptr< RenderObject > > ret{}; + for ( const auto &x : collisionObjects ) { + if ( objectIDs.find( x->getId() ) != objectIDs.end() && + x->colidesWith( r ) ) { + ret.push_back( x ); } } return ret; } - void renderScene(bool clear_scene = true) { + void renderScene( bool clear_scene = true ) { checkKilled(); render_mutex.lock(); - if(clear_scene) - SDL_RenderClear(renderer->getRendererPtr()); - if(background && background->getTexturePtr()) - SDL_RenderCopy(renderer->getRendererPtr(), background->getTexturePtr(), NULL, NULL); - for( const auto &x : renderObjects ) { + if ( clear_scene ) + SDL_RenderClear( renderer->getRendererPtr() ); + if ( background && background->getTexturePtr() ) + SDL_RenderCopy( renderer->getRendererPtr(), + background->getTexturePtr(), NULL, NULL ); + for ( const auto &x : renderObjects ) { x->render(); } render_mutex.unlock(); } void presentScene() { - SDL_RenderPresent(renderer->getRendererPtr()); + SDL_RenderPresent( renderer->getRendererPtr() ); } - void setBackground(std::shared_ptr bg) { + void setBackground( std::shared_ptr< Texture > bg ) { background = bg; } - void setBackground(const std::string &img_path) { - background = std::make_shared(renderer, img_path); + void setBackground( const std::string &img_path ) { + background = std::make_shared< Texture >( renderer, img_path ); } void updateSizeAndPosition() { checkKilled(); render_mutex.lock(); - for( auto &x : renderObjects ) { + for ( auto &x : renderObjects ) { x->updateSizeAndPosition(); - for( auto &col : x->getCollisions() ) { - col->updateCollision(x->collisionPushX(), x->collisionPushY(), x->collisionWidth(), x->collisionHeight()); + for ( auto &col : x->getCollisions() ) { + col->updateCollision( x->collisionPushX(), x->collisionPushY(), + x->collisionWidth(), + x->collisionHeight() ); } } render_mutex.unlock(); } - void moveEverything(double x, double y) { + void moveEverything( double x, double y ) { checkKilled(); render_mutex.lock(); - for( auto &obj : renderObjects ) { - if(obj->getPermanent()) + for ( auto &obj : renderObjects ) { + if ( obj->getPermanent() ) continue; auto curPos = obj->getDoubleRect(); obj->setPos( curPos.first.first + x, curPos.first.second + y ); } render_mutex.unlock(); } - const std::shared_ptr &leftmost() { + const std::shared_ptr< RenderObject > &leftmost() { return leftmost_obj; } - const std::shared_ptr &rightmost() { + const std::shared_ptr< RenderObject > &rightmost() { return rightmost_obj; } - std::pair getDimensions() const { + std::pair< int, int > getDimensions() const { return renderer->getDimensions(); } int getWidth() const { @@ -510,94 +569,110 @@ public: Renderer &getRenderer() { return *renderer; } - void setPrevTicks(int ticks) { + void setPrevTicks( int ticks ) { prev_ticks = ticks; } + private: void checkKilled() { render_mutex.lock(); - std::vector killed; - for( long unsigned int i = 0; i < renderObjects.size(); i++ ) { - if(renderObjects[i]->getKilled()) - killed.push_back(i); + std::vector< int > killed; + for ( long unsigned int i = 0; i < renderObjects.size(); i++ ) { + if ( renderObjects[i]->getKilled() ) + killed.push_back( i ); } - std::reverse(killed.begin(), killed.end()); - for(auto &index : killed) { - renderObjects.erase(renderObjects.begin() + index); + std::reverse( killed.begin(), killed.end() ); + for ( auto &index : killed ) { + renderObjects.erase( renderObjects.begin() + index ); } render_mutex.unlock(); } - std::vector> renderObjects; - std::vector> collisionObjects; - std::shared_ptr renderer; - std::shared_ptr background; + std::vector< std::shared_ptr< RenderObject > > renderObjects; + std::vector< std::shared_ptr< RenderObject > > collisionObjects; + std::shared_ptr< Renderer > renderer; + std::shared_ptr< Texture > background; int prev_ticks = 0; - std::shared_ptr leftmost_obj; - std::shared_ptr rightmost_obj; + std::shared_ptr< RenderObject > leftmost_obj; + std::shared_ptr< RenderObject > rightmost_obj; uint64_t max_object_id = 0; std::mutex render_mutex; }; class Rect : public CollisionPolygon { public: - Rect(double x, double y, double w, double h) : CollisionPolygon(x, y) { + Rect( double x, double y, double w, double h ) : CollisionPolygon( x, y ) { w_ = w; h_ = h; } virtual ~Rect() {} - virtual bool colidesWith(const CollisionPolygon &other) const override; - virtual bool isCircle() const override { return false; } + virtual bool colidesWith( const CollisionPolygon &other ) const override; + virtual bool isCircle() const override { + return false; + } virtual int topmost() const override { - return (!isInfinite() || original_y != -1) * getY() + isInfinite() * -1; + return ( !isInfinite() || original_y != -1 ) * getY() + + isInfinite() * -1; } virtual int bottommost() const override { - return (!isInfinite() || h_ != -1) * (getY() + pixel_h) + isInfinite() * -1; + return ( !isInfinite() || h_ != -1 ) * ( getY() + pixel_h ) + + isInfinite() * -1; }; virtual int leftmost() const override { - return (!isInfinite() || original_x != -1) * getX() + isInfinite() * -1; + return ( !isInfinite() || original_x != -1 ) * getX() + + isInfinite() * -1; } virtual int rightmost() const override { - return (!isInfinite() || w_ != -1) * (getX() + pixel_w) + isInfinite() * -1; + return ( !isInfinite() || w_ != -1 ) * ( getX() + pixel_w ) + + isInfinite() * -1; } - virtual void updateCollision(int x, int y, int w, int h) override { + virtual void updateCollision( int x, int y, int w, int h ) override { position_x = original_x * w + x; position_y = original_y * h + y; pixel_w = w_ * w; pixel_h = h_ * h; } - virtual void render(Renderer &renderer, const std::tuple &color) override { + virtual void + render( Renderer &renderer, + const std::tuple< int, int, int, int > &color ) override { auto rect = getRect(); // outline with desired color at 50% opacity - SDL_SetRenderDrawColor(renderer.getRendererPtr(), std::get<0>(color), std::get<1>(color), std::get<2>(color), 0x80); - SDL_RenderDrawRect(renderer.getRendererPtr(), &rect); + SDL_SetRenderDrawColor( renderer.getRendererPtr(), + std::get< 0 >( color ), std::get< 1 >( color ), + std::get< 2 >( color ), 0x80 ); + SDL_RenderDrawRect( renderer.getRendererPtr(), &rect ); // fill with desired color at 25% opacity - SDL_SetRenderDrawColor(renderer.getRendererPtr(), std::get<0>(color), std::get<1>(color), std::get<2>(color), 0x40); - SDL_RenderFillRect(renderer.getRendererPtr(), &rect); + SDL_SetRenderDrawColor( renderer.getRendererPtr(), + std::get< 0 >( color ), std::get< 1 >( color ), + std::get< 2 >( color ), 0x40 ); + SDL_RenderFillRect( renderer.getRendererPtr(), &rect ); } - virtual void render(Renderer &renderer) override { + virtual void render( Renderer &renderer ) override { auto rect = getRect(); - SDL_SetRenderDrawColor(renderer.getRendererPtr(), sdl_color.r, sdl_color.g, sdl_color.b, sdl_color.a); - SDL_RenderFillRect(renderer.getRendererPtr(), &rect); - SDL_SetRenderDrawColor(renderer.getRendererPtr(), sdl_outline.r, sdl_outline.g, sdl_outline.b, sdl_outline.a); - SDL_RenderDrawRect(renderer.getRendererPtr(), &rect); + SDL_SetRenderDrawColor( renderer.getRendererPtr(), sdl_color.r, + sdl_color.g, sdl_color.b, sdl_color.a ); + SDL_RenderFillRect( renderer.getRendererPtr(), &rect ); + SDL_SetRenderDrawColor( renderer.getRendererPtr(), sdl_outline.r, + sdl_outline.g, sdl_outline.b, sdl_outline.a ); + SDL_RenderDrawRect( renderer.getRendererPtr(), &rect ); } + private: SDL_Rect getRect() { - if( !isInfinite() ) - return {leftmost(), topmost(), pixel_w, pixel_h}; + if ( !isInfinite() ) + return { leftmost(), topmost(), pixel_w, pixel_h }; - SDL_Rect r = {0,0,0,0}; - if((r.x = leftmost()) == -1) + SDL_Rect r = { 0, 0, 0, 0 }; + if ( ( r.x = leftmost() ) == -1 ) r.x = 0; - if((r.y = topmost()) == -1) + if ( ( r.y = topmost() ) == -1 ) r.y = 0; - if(rightmost() == -1) - r.w = std::numeric_limits::max(); + if ( rightmost() == -1 ) + r.w = std::numeric_limits< int >::max(); else r.w = pixel_w; - if(bottommost() == -1) - r.h = std::numeric_limits::max(); + if ( bottommost() == -1 ) + r.h = std::numeric_limits< int >::max(); else r.h = pixel_h; return r; @@ -611,58 +686,96 @@ private: class Circle : public CollisionPolygon { public: - Circle(double x, double y, double rad) : CollisionPolygon(x, y) { + Circle( double x, double y, double rad ) : CollisionPolygon( x, y ) { original_rad = rad; } virtual ~Circle() {} - virtual bool colidesWith(const CollisionPolygon &other) const override; - virtual bool isCircle() const override { return true; } - virtual int topmost() const override { return getY() - rad_; } - virtual int bottommost() const override { return getY() + rad_; }; - virtual int leftmost() const override { return getX() - rad_; } - virtual int rightmost() const override { return getX() + rad_; } - virtual void updateCollision(int x, int y, int w, int h) override { + virtual bool colidesWith( const CollisionPolygon &other ) const override; + virtual bool isCircle() const override { + return true; + } + virtual int topmost() const override { + return getY() - rad_; + } + virtual int bottommost() const override { + return getY() + rad_; + }; + virtual int leftmost() const override { + return getX() - rad_; + } + virtual int rightmost() const override { + return getX() + rad_; + } + virtual void updateCollision( int x, int y, int w, int h ) override { position_x = original_x * w + x; position_y = original_y * h + y; rad_ = original_rad * w; } - virtual void render(Renderer &renderer, const std::tuple &color) override { - std::vector rect = {leftmost(), topmost(), rightmost(), bottommost()}; + virtual void + render( Renderer &renderer, + const std::tuple< int, int, int, int > &color ) override { + std::vector< int > rect = { leftmost(), topmost(), rightmost(), + bottommost() }; auto center_x = getX(); auto center_y = getY(); auto radsq = rad_ * rad_; - for(int i = rect[0]; i <= rect[2]; i++) { + for ( int i = rect[0]; i <= rect[2]; i++ ) { auto xdiff = center_x - i; auto xdist = xdiff * xdiff; - auto allowed_rad = sqrt(radsq - xdist); - SDL_SetRenderDrawColor(renderer.getRendererPtr(), std::get<0>(color), std::get<1>(color), std::get<2>(color), 0x40); - SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y - allowed_rad, i, center_y + allowed_rad); - SDL_SetRenderDrawColor(renderer.getRendererPtr(), std::get<0>(color), std::get<1>(color), std::get<2>(color), 0x80); - SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y - allowed_rad, i, center_y - allowed_rad + 2); - SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y + allowed_rad, i, center_y + allowed_rad - 2); + auto allowed_rad = sqrt( radsq - xdist ); + SDL_SetRenderDrawColor( + renderer.getRendererPtr(), std::get< 0 >( color ), + std::get< 1 >( color ), std::get< 2 >( color ), 0x40 ); + SDL_RenderDrawLine( renderer.getRendererPtr(), i, + center_y - allowed_rad, i, + center_y + allowed_rad ); + SDL_SetRenderDrawColor( + renderer.getRendererPtr(), std::get< 0 >( color ), + std::get< 1 >( color ), std::get< 2 >( color ), 0x80 ); + SDL_RenderDrawLine( renderer.getRendererPtr(), i, + center_y - allowed_rad, i, + center_y - allowed_rad + 2 ); + SDL_RenderDrawLine( renderer.getRendererPtr(), i, + center_y + allowed_rad, i, + center_y + allowed_rad - 2 ); } - SDL_SetRenderDrawColor(renderer.getRendererPtr(), 0xFF, 0, 0, 0xFF); - SDL_RenderDrawLine(renderer.getRendererPtr(), center_x, center_y, center_x + rad_, center_y); - SDL_RenderDrawLine(renderer.getRendererPtr(), center_x, center_y, center_x, center_y + rad_); - SDL_RenderDrawLine(renderer.getRendererPtr(), center_x, center_y, center_x - rad_, center_y); - SDL_RenderDrawLine(renderer.getRendererPtr(), center_x, center_y, center_x, center_y - rad_); + SDL_SetRenderDrawColor( renderer.getRendererPtr(), 0xFF, 0, 0, 0xFF ); + SDL_RenderDrawLine( renderer.getRendererPtr(), center_x, center_y, + center_x + rad_, center_y ); + SDL_RenderDrawLine( renderer.getRendererPtr(), center_x, center_y, + center_x, center_y + rad_ ); + SDL_RenderDrawLine( renderer.getRendererPtr(), center_x, center_y, + center_x - rad_, center_y ); + SDL_RenderDrawLine( renderer.getRendererPtr(), center_x, center_y, + center_x, center_y - rad_ ); } - virtual void render(Renderer &renderer) override { - std::vector rect = {leftmost(), topmost(), rightmost(), bottommost()}; + virtual void render( Renderer &renderer ) override { + std::vector< int > rect = { leftmost(), topmost(), rightmost(), + bottommost() }; auto center_x = getX(); auto center_y = getY(); auto radsq = rad_ * rad_; - for(int i = rect[0]; i <= rect[2]; i++) { + for ( int i = rect[0]; i <= rect[2]; i++ ) { auto xdiff = center_x - i; auto xdist = xdiff * xdiff; - auto allowed_rad = sqrt(radsq - xdist); - SDL_SetRenderDrawColor(renderer.getRendererPtr(), sdl_color.r, sdl_color.g, sdl_color.b, sdl_color.a); - SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y - allowed_rad, i, center_y + allowed_rad); - SDL_SetRenderDrawColor(renderer.getRendererPtr(), sdl_outline.r, sdl_outline.g, sdl_outline.b, sdl_outline.a); - SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y - allowed_rad, i, center_y - allowed_rad + 2); - SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y + allowed_rad, i, center_y + allowed_rad - 2); + auto allowed_rad = sqrt( radsq - xdist ); + SDL_SetRenderDrawColor( renderer.getRendererPtr(), sdl_color.r, + sdl_color.g, sdl_color.b, sdl_color.a ); + SDL_RenderDrawLine( renderer.getRendererPtr(), i, + center_y - allowed_rad, i, + center_y + allowed_rad ); + SDL_SetRenderDrawColor( renderer.getRendererPtr(), sdl_outline.r, + sdl_outline.g, sdl_outline.b, + sdl_outline.a ); + SDL_RenderDrawLine( renderer.getRendererPtr(), i, + center_y - allowed_rad, i, + center_y - allowed_rad + 2 ); + SDL_RenderDrawLine( renderer.getRendererPtr(), i, + center_y + allowed_rad, i, + center_y + allowed_rad - 2 ); } } + private: int getRadius() const { return rad_; @@ -674,77 +787,95 @@ private: class RectangleRender : public RenderObject { public: RectangleRender() = delete; - virtual ~RectangleRender() {}; - RectangleRender(double x, double y, double w, double h, std::shared_ptr &r) : RenderObject(r) { + virtual ~RectangleRender(){}; + RectangleRender( double x, double y, double w, double h, + std::shared_ptr< Renderer > &r ) + : RenderObject( r ) { og_x = x_ = x; og_y = y_ = y; og_w = w_ = w; og_h = h_ = h; updateSizeAndPosition(); } - RectangleRender(double x, double y, double w, double h, std::shared_ptr &r, std::shared_ptr &t) : RectangleRender(x, y, w, h, r) { - setTexture(t); + RectangleRender( double x, double y, double w, double h, + std::shared_ptr< Renderer > &r, + std::shared_ptr< Texture > &t ) + : RectangleRender( x, y, w, h, r ) { + setTexture( t ); } - RectangleRender(double x, double y, double w, double h, std::shared_ptr &r, const std::string &img_or_color, bool is_polygon = false) : RectangleRender(x,y,w,h,r) { - if(!is_polygon) { - setTexture(img_or_color); + RectangleRender( double x, double y, double w, double h, + std::shared_ptr< Renderer > &r, + const std::string &img_or_color, bool is_polygon = false ) + : RectangleRender( x, y, w, h, r ) { + if ( !is_polygon ) { + setTexture( img_or_color ); } else { - setColor(img_or_color); + setColor( img_or_color ); } } - virtual void setColor(const std::string &color) override { - if(!polygon) { - polygon = std::make_shared(0,0,1,1); - polygon->updateCollision(collisionPushX(), collisionPushY(), collisionWidth(), collisionHeight()); + virtual void setColor( const std::string &color ) override { + if ( !polygon ) { + polygon = std::make_shared< Rect >( 0, 0, 1, 1 ); + polygon->updateCollision( collisionPushX(), collisionPushY(), + collisionWidth(), collisionHeight() ); } - polygon->setColor(color); + polygon->setColor( color ); } - virtual void setOutlineColor(const std::string &color) override { - if(!polygon) { - polygon = std::make_shared(0,0,1,1); - polygon->updateCollision(collisionPushX(), collisionPushY(), collisionWidth(), collisionHeight()); + virtual void setOutlineColor( const std::string &color ) override { + if ( !polygon ) { + polygon = std::make_shared< Rect >( 0, 0, 1, 1 ); + polygon->updateCollision( collisionPushX(), collisionPushY(), + collisionWidth(), collisionHeight() ); } - polygon->setOutlineColor(color); + polygon->setOutlineColor( color ); } - virtual void specialAction(int /*UNUSED*/) override {}; + virtual void specialAction( int /*UNUSED*/ ) override{}; virtual void render() override { - if(!getHidden()) { - if(polygon) - polygon->render(*renderer); - if(texture != NULL) - SDL_RenderCopy(renderer->getRendererPtr(), texture->getTexturePtr(), NULL, &rect); + if ( !getHidden() ) { + if ( polygon ) + polygon->render( *renderer ); + if ( texture != NULL ) + SDL_RenderCopy( renderer->getRendererPtr(), + texture->getTexturePtr(), NULL, &rect ); } - if(hasCollisions() && renderer->getRenderColiders() && !getHidden()) { - for(const auto &col : getCollisions()) - col->render(*renderer, colider_color); + if ( hasCollisions() && renderer->getRenderColiders() && + !getHidden() ) { + for ( const auto &col : getCollisions() ) + col->render( *renderer, colider_color ); } } - virtual void move(int ticks) override { - if(permanent) + virtual void move( int ticks ) override { + if ( permanent ) return; - auto addx = static_cast(movementSpeed * movementDirection.first)*(static_cast(ticks)/1000); - auto addy = static_cast(movementSpeed * movementDirection.second)*(static_cast(ticks)/1000); - if(std::isnan(addx) || std::isnan(addy)) + auto addx = + static_cast< double >( movementSpeed * movementDirection.first ) * + ( static_cast< double >( ticks ) / 1000 ); + auto addy = + static_cast< double >( movementSpeed * movementDirection.second ) * + ( static_cast< double >( ticks ) / 1000 ); + if ( std::isnan( addx ) || std::isnan( addy ) ) return; og_x += addx; og_y += addy; - custom_move(ticks); + custom_move( ticks ); updateSizeAndPosition(); } - virtual void custom_move(int /*UNUSED*/) override {} - virtual std::pair,std::pair> getDoubleRect() override { - return {{og_x,og_y}, {og_w,og_h}}; + virtual void custom_move( int /*UNUSED*/ ) override {} + virtual std::pair< std::pair< double, double >, + std::pair< double, double > > + getDoubleRect() override { + return { { og_x, og_y }, { og_w, og_h } }; } - virtual void setPos(double x, double y) override { + virtual void setPos( double x, double y ) override { og_x = x; og_y = y; updateSizeAndPosition(); } - virtual std::pair getPos() override { - return {og_x, og_y}; + virtual std::pair< double, double > getPos() override { + return { og_x, og_y }; } virtual int leftmost() override { return rect.x; @@ -777,10 +908,12 @@ public: rect.y = y_ * dimension; rect.w = w_ * dimension; rect.h = h_ * dimension; - if(polygon) - polygon->updateCollision(collisionPushX(), collisionPushY(), collisionWidth(), collisionHeight()); - for( auto &x : collisions ) { - x->updateCollision(collisionPushX(), collisionPushY(), collisionWidth(), collisionHeight()); + if ( polygon ) + polygon->updateCollision( collisionPushX(), collisionPushY(), + collisionWidth(), collisionHeight() ); + for ( auto &x : collisions ) { + x->updateCollision( collisionPushX(), collisionPushY(), + collisionWidth(), collisionHeight() ); } } virtual SDL_Rect getRect() override { @@ -790,18 +923,20 @@ public: centerx = true; updateSizeAndPosition(); } + protected: void updateXY() { - if(!centerx) { + if ( !centerx ) { x_ = og_x; y_ = og_y; return; } auto width = renderer->getWidth(); auto height = renderer->getHeight(); - if(width > height) { - auto multiplier = static_cast(width)/static_cast(height); - x_ = og_x + static_cast(multiplier - 1)/2; + if ( width > height ) { + auto multiplier = static_cast< double >( width ) / + static_cast< double >( height ); + x_ = og_x + static_cast< double >( multiplier - 1 ) / 2; } else { x_ = og_x; } @@ -822,48 +957,64 @@ protected: class TextRenderer : public RectangleRender { public: TextRenderer() = delete; - TextRenderer( double x, double y, double w, double h, std::shared_ptr &r ) : RectangleRender(x, y, w, h, r) {} - TextRenderer( double x, double y, double w, double h, std::shared_ptr &r, Font &font, const std::string &text, const std::string &color = "FFFFFF", const std::string &outline_color = "000000", int outline_size = -1, int flags = SDLPP_TEXT_CENTER ) : RectangleRender(x, y, w, h, r) { + TextRenderer( double x, double y, double w, double h, + std::shared_ptr< Renderer > &r ) + : RectangleRender( x, y, w, h, r ) {} + TextRenderer( double x, double y, double w, double h, + std::shared_ptr< Renderer > &r, Font &font, + const std::string &text, const std::string &color = "FFFFFF", + const std::string &outline_color = "000000", + int outline_size = -1, int flags = SDLPP_TEXT_CENTER ) + : RectangleRender( x, y, w, h, r ) { position_flags = flags; - setText(font, text, color, outline_color, outline_size); + setText( font, text, color, outline_color, outline_size ); } - void setText(Font &font, const std::string &text, const std::string &color = "FFFFFF", const std::string &outline_color = "000000", int outline_size = -1) { - setTexture(font, text, color, outline_color, outline_size); + void setText( Font &font, const std::string &text, + const std::string &color = "FFFFFF", + const std::string &outline_color = "000000", + int outline_size = -1 ) { + setTexture( font, text, color, outline_color, outline_size ); updateDstRect(); } - void setFlags(int flags) { + void setFlags( int flags ) { position_flags = flags; updateDstRect(); } virtual void render() override { - if(!getHidden()) { - if(polygon) - polygon->render(*renderer); - if(texture != NULL) - SDL_RenderCopy(renderer->getRendererPtr(), texture->getTexturePtr(), NULL, &dst_rect); + if ( !getHidden() ) { + if ( polygon ) + polygon->render( *renderer ); + if ( texture != NULL ) + SDL_RenderCopy( renderer->getRendererPtr(), + texture->getTexturePtr(), NULL, &dst_rect ); } - if(hasCollisions() && renderer->getRenderColiders() && !getHidden()) { - for(const auto &col : getCollisions()) - col->render(*renderer, colider_color); + if ( hasCollisions() && renderer->getRenderColiders() && + !getHidden() ) { + for ( const auto &col : getCollisions() ) + col->render( *renderer, colider_color ); } } virtual void updateSizeAndPosition() override { RectangleRender::updateSizeAndPosition(); updateDstRect(); } + private: void updateDstRect() { - if(!texture) + if ( !texture ) return; int text_width{}, text_height{}; - SDL_QueryTexture(texture->getTexturePtr(), NULL, NULL, &text_width, &text_height); - if(text_width < rect.w && text_height < rect.h) { + SDL_QueryTexture( texture->getTexturePtr(), NULL, NULL, &text_width, + &text_height ); + if ( text_width < rect.w && text_height < rect.h ) { dst_rect.w = text_width; dst_rect.h = text_height; } else { - double x_div = static_cast(text_width)/static_cast(rect.w); - double y_div = static_cast(text_height)/static_cast(rect.h); - if(x_div > y_div) { + double x_div = static_cast< double >( text_width ) / + static_cast< double >( rect.w ); + double y_div = static_cast< double >( text_height ) / + static_cast< double >( rect.h ); + if ( x_div > y_div ) { dst_rect.w = text_width / x_div; dst_rect.h = text_height / x_div; } else { @@ -871,18 +1022,20 @@ private: dst_rect.h = text_height / y_div; } } - if(!(position_flags & SDLPP_TEXT_LEFT || position_flags & SDLPP_TEXT_RIGHT)) { - dst_rect.x = rect.x + (rect.w - dst_rect.w)/2; - } else if(position_flags & SDLPP_TEXT_LEFT) { + if ( !( position_flags & SDLPP_TEXT_LEFT || + position_flags & SDLPP_TEXT_RIGHT ) ) { + dst_rect.x = rect.x + ( rect.w - dst_rect.w ) / 2; + } else if ( position_flags & SDLPP_TEXT_LEFT ) { dst_rect.x = rect.x; - } else if(position_flags & SDLPP_TEXT_RIGHT) { + } else if ( position_flags & SDLPP_TEXT_RIGHT ) { dst_rect.x = rect.x + rect.w - dst_rect.w; } - if(!(position_flags & SDLPP_TEXT_TOP || position_flags & SDLPP_TEXT_BOTTOM)) { - dst_rect.y = rect.y + (rect.h - dst_rect.h)/2; - } else if(position_flags & SDLPP_TEXT_TOP) { + if ( !( position_flags & SDLPP_TEXT_TOP || + position_flags & SDLPP_TEXT_BOTTOM ) ) { + dst_rect.y = rect.y + ( rect.h - dst_rect.h ) / 2; + } else if ( position_flags & SDLPP_TEXT_TOP ) { dst_rect.y = rect.y; - } else if(position_flags & SDLPP_TEXT_BOTTOM) { + } else if ( position_flags & SDLPP_TEXT_BOTTOM ) { dst_rect.y = rect.y + rect.h - dst_rect.h; } } @@ -893,25 +1046,30 @@ private: class CircleRender : public RenderObject { public: CircleRender() = delete; - virtual ~CircleRender() {}; - CircleRender(int x, int y, int rad, std::shared_ptr &r) : RenderObject(r) { + virtual ~CircleRender(){}; + CircleRender( int x, int y, int rad, std::shared_ptr< Renderer > &r ) + : RenderObject( r ) { x_ = x; y_ = y; rad_ = rad; } - CircleRender(int x, int y, int rad, std::shared_ptr &r, std::shared_ptr &t) : CircleRender(x,y,rad,r) { - setTexture(t); + CircleRender( int x, int y, int rad, std::shared_ptr< Renderer > &r, + std::shared_ptr< Texture > &t ) + : CircleRender( x, y, rad, r ) { + setTexture( t ); } - CircleRender(int x, int y, int rad, std::shared_ptr &r, const std::string &img_path) : CircleRender(x,y,rad,r) { - auto texture = std::make_shared(r, img_path); - setTexture(texture); + CircleRender( int x, int y, int rad, std::shared_ptr< Renderer > &r, + const std::string &img_path ) + : CircleRender( x, y, rad, r ) { + auto texture = std::make_shared< Texture >( r, img_path ); + setTexture( texture ); } virtual void render(); virtual int leftmost() { - return x_-rad_; + return x_ - rad_; } virtual int topmost() { - return y_-rad_; + return y_ - rad_; } virtual int collisionPushX() { return x_; @@ -919,6 +1077,7 @@ public: virtual int collisionPushY() { return y_; } + private: int x_; int y_; @@ -926,11 +1085,10 @@ private: }; bool init(); -bool init(uint32_t SDL_OPTIONS); -bool init(uint32_t SDL_OPTIONS, int IMAGE_OPTIONS); +bool init( uint32_t SDL_OPTIONS ); +bool init( uint32_t SDL_OPTIONS, int IMAGE_OPTIONS ); -template -void testPolymorphism(T &obj); +template < class T > void testPolymorphism( T &obj ); } // end of namespace SDLPP diff --git a/tetris.cpp b/tetris.cpp index a5913ff..038c158 100644 --- a/tetris.cpp +++ b/tetris.cpp @@ -14,33 +14,34 @@ int pause_max = 1; int ticks_till_next = 1500; int ticks_till_fall = 500; int ticks_till_descend = 50; -std::vector> pause_options; -std::shared_ptr score_texture; -std::shared_ptr active_renderer; +std::vector< std::shared_ptr< SDLPP::RectangleRender > > pause_options; +std::shared_ptr< SDLPP::TextRenderer > score_texture; +std::shared_ptr< SDLPP::Renderer > active_renderer; int score = 0; bool update_score = false; -std::shared_ptr font; -std::shared_ptr active_scene; -std::shared_ptr pause_scene; +std::shared_ptr< SDLPP::Font > font; +std::shared_ptr< SDLPP::Scene > active_scene; +std::shared_ptr< SDLPP::Scene > pause_scene; class TetrisPiece { public: - void addPiece(std::shared_ptr piece, int x, int y) { - pieces.push_back(piece); - pieces_rel_position.push_back({0,0,0,0}); + void addPiece( std::shared_ptr< SDLPP::RectangleRender > piece, int x, + int y ) { + pieces.push_back( piece ); + pieces_rel_position.push_back( { 0, 0, 0, 0 } ); // done this way for SPEEEEEEED - //left - pieces_rel_position.back()[0] = (x<0)*(-1)*x; - //right - pieces_rel_position.back()[1] = (x>0)*x; - //top - pieces_rel_position.back()[2] = (y<0)*(-1)*y; - //bottom - pieces_rel_position.back()[3] = (y>0)*y; + // left + pieces_rel_position.back()[0] = ( x < 0 ) * ( -1 ) * x; + // right + pieces_rel_position.back()[1] = ( x > 0 ) * x; + // top + pieces_rel_position.back()[2] = ( y < 0 ) * ( -1 ) * y; + // bottom + pieces_rel_position.back()[3] = ( y > 0 ) * y; } void rotate() { - for(unsigned long i = 0; i < pieces.size(); i++) { + for ( unsigned long i = 0; i < pieces.size(); i++ ) { auto &piece = pieces[i]; auto &positions = pieces_rel_position[i]; auto position = piece->getPos(); @@ -58,22 +59,22 @@ public: position.first += positions[1] * 0.04; position.second -= positions[2] * 0.04; position.second += positions[3] * 0.04; - piece->setPos(position.first, position.second); + piece->setPos( position.first, position.second ); } } - std::vector> &getObjects() { + std::vector< std::shared_ptr< SDLPP::RectangleRender > > &getObjects() { return pieces; } - void setPos(double x, double y) { - for(unsigned long i = 0; i < pieces.size(); i++) { + void setPos( double x, double y ) { + for ( unsigned long i = 0; i < pieces.size(); i++ ) { auto &piece = pieces[i]; auto pos = piece->getPos(); - piece->setPos(x + pos.first - default_x, - y + pos.second - default_y); + piece->setPos( x + pos.first - default_x, + y + pos.second - default_y ); } - setDefPos(x, y); + setDefPos( x, y ); } - void setDefPos(double x, double y) { + void setDefPos( double x, double y ) { default_x = x; default_y = y; } @@ -90,199 +91,274 @@ public: bool isDescending() { return descend; } + private: - std::vector> pieces_rel_position; - std::vector> pieces; + std::vector< std::vector< int > > pieces_rel_position; + std::vector< std::shared_ptr< SDLPP::RectangleRender > > pieces; double default_x; double default_y; bool descend = false; }; -std::vector> line_coliders; +std::vector< std::shared_ptr< SDLPP::RectangleRender > > line_coliders; TetrisPiece cur_object; TetrisPiece next_object; -void doInput(std::shared_ptr scene); +void doInput( std::shared_ptr< SDLPP::Scene > scene ); void doInputPause(); bool quit = false; std::mutex movement_mutex; -std::shared_ptr createTetrisBlock(double x, double y, const std::string &color, const std::string &outline, std::shared_ptr renderer, std::shared_ptr scene) { - auto ret = std::make_shared(x, y, 0.04, 0.04, renderer, color, true); - ret->setOutlineColor(outline); - ret->addCollision(SDLPP::Rect(0.1,0.1,0.8,0.8)); - ret->setId(BRICK_ID); +std::shared_ptr< SDLPP::RectangleRender > +createTetrisBlock( double x, double y, const std::string &color, + const std::string &outline, + std::shared_ptr< SDLPP::Renderer > renderer, + std::shared_ptr< SDLPP::Scene > scene ) { + auto ret = std::make_shared< SDLPP::RectangleRender >( + x, y, 0.04, 0.04, renderer, color, true ); + ret->setOutlineColor( outline ); + ret->addCollision( SDLPP::Rect( 0.1, 0.1, 0.8, 0.8 ) ); + ret->setId( BRICK_ID ); ret->centerX(); - scene->addObject(ret); + scene->addObject( ret ); return ret; } -TetrisPiece tetrisBrick(std::shared_ptr renderer, std::shared_ptr scene) { +TetrisPiece tetrisBrick( std::shared_ptr< SDLPP::Renderer > renderer, + std::shared_ptr< SDLPP::Scene > scene ) { TetrisPiece retPiece{}; auto color = "#FF0000"; auto outline = "#AA0000"; - retPiece.addPiece(createTetrisBlock(0.46, 0.16, color, outline, renderer, scene), 0, 0); - retPiece.addPiece(createTetrisBlock(0.5, 0.16, color, outline, renderer, scene), 0, 0); - retPiece.addPiece(createTetrisBlock(0.46, 0.20, color, outline, renderer, scene), 0, 0); - retPiece.addPiece(createTetrisBlock(0.5, 0.20, color, outline, renderer, scene), 0, 0); - retPiece.setDefPos(0.5, 0.16); + retPiece.addPiece( + createTetrisBlock( 0.46, 0.16, color, outline, renderer, scene ), 0, + 0 ); + retPiece.addPiece( + createTetrisBlock( 0.5, 0.16, color, outline, renderer, scene ), 0, 0 ); + retPiece.addPiece( + createTetrisBlock( 0.46, 0.20, color, outline, renderer, scene ), 0, + 0 ); + retPiece.addPiece( + createTetrisBlock( 0.5, 0.20, color, outline, renderer, scene ), 0, 0 ); + retPiece.setDefPos( 0.5, 0.16 ); return retPiece; } -TetrisPiece tetrisT(std::shared_ptr renderer, std::shared_ptr scene) { +TetrisPiece tetrisT( std::shared_ptr< SDLPP::Renderer > renderer, + std::shared_ptr< SDLPP::Scene > scene ) { TetrisPiece retPiece{}; auto color = "#00FF00"; auto outline = "#00AA00"; - retPiece.addPiece(createTetrisBlock(0.46, 0.20, color, outline, renderer, scene), -1, 0); - retPiece.addPiece(createTetrisBlock(0.5, 0.20, color, outline, renderer, scene), 0, 0); - retPiece.addPiece(createTetrisBlock(0.5, 0.16, color, outline, renderer, scene), 0, -1); - retPiece.addPiece(createTetrisBlock(0.54, 0.20, color, outline, renderer, scene), 1, 0); - retPiece.setDefPos(0.5, 0.16); + retPiece.addPiece( + createTetrisBlock( 0.46, 0.20, color, outline, renderer, scene ), -1, + 0 ); + retPiece.addPiece( + createTetrisBlock( 0.5, 0.20, color, outline, renderer, scene ), 0, 0 ); + retPiece.addPiece( + createTetrisBlock( 0.5, 0.16, color, outline, renderer, scene ), 0, + -1 ); + retPiece.addPiece( + createTetrisBlock( 0.54, 0.20, color, outline, renderer, scene ), 1, + 0 ); + retPiece.setDefPos( 0.5, 0.16 ); return retPiece; } -TetrisPiece tetrisLRight(std::shared_ptr renderer, std::shared_ptr scene) { +TetrisPiece tetrisLRight( std::shared_ptr< SDLPP::Renderer > renderer, + std::shared_ptr< SDLPP::Scene > scene ) { TetrisPiece retPiece{}; auto color = "#0000FF"; auto outline = "#0000AA"; - retPiece.addPiece(createTetrisBlock(0.46, 0.20, color, outline, renderer, scene), -2, 0); - retPiece.addPiece(createTetrisBlock(0.5, 0.20, color, outline, renderer, scene), -1, 0); - retPiece.addPiece(createTetrisBlock(0.54, 0.20, color, outline, renderer, scene), 0, 0); - retPiece.addPiece(createTetrisBlock(0.54, 0.16, color, outline, renderer, scene), 0, -1); - retPiece.setDefPos(0.5, 0.16); + retPiece.addPiece( + createTetrisBlock( 0.46, 0.20, color, outline, renderer, scene ), -2, + 0 ); + retPiece.addPiece( + createTetrisBlock( 0.5, 0.20, color, outline, renderer, scene ), -1, + 0 ); + retPiece.addPiece( + createTetrisBlock( 0.54, 0.20, color, outline, renderer, scene ), 0, + 0 ); + retPiece.addPiece( + createTetrisBlock( 0.54, 0.16, color, outline, renderer, scene ), 0, + -1 ); + retPiece.setDefPos( 0.5, 0.16 ); return retPiece; } -TetrisPiece tetrisZRight(std::shared_ptr renderer, std::shared_ptr scene) { +TetrisPiece tetrisZRight( std::shared_ptr< SDLPP::Renderer > renderer, + std::shared_ptr< SDLPP::Scene > scene ) { TetrisPiece retPiece{}; auto color = "#FF00FF"; auto outline = "#AA00AA"; - retPiece.addPiece(createTetrisBlock(0.46, 0.20, color, outline, renderer, scene), -1, 0); - retPiece.addPiece(createTetrisBlock(0.5, 0.20, color, outline, renderer, scene), 0, 0); - retPiece.addPiece(createTetrisBlock(0.5, 0.16, color, outline, renderer, scene), 0, -1); - retPiece.addPiece(createTetrisBlock(0.54, 0.16, color, outline, renderer, scene), 1, -1); - retPiece.setDefPos(0.5, 0.16); + retPiece.addPiece( + createTetrisBlock( 0.46, 0.20, color, outline, renderer, scene ), -1, + 0 ); + retPiece.addPiece( + createTetrisBlock( 0.5, 0.20, color, outline, renderer, scene ), 0, 0 ); + retPiece.addPiece( + createTetrisBlock( 0.5, 0.16, color, outline, renderer, scene ), 0, + -1 ); + retPiece.addPiece( + createTetrisBlock( 0.54, 0.16, color, outline, renderer, scene ), 1, + -1 ); + retPiece.setDefPos( 0.5, 0.16 ); return retPiece; } -TetrisPiece tetrisLine(std::shared_ptr renderer, std::shared_ptr scene) { +TetrisPiece tetrisLine( std::shared_ptr< SDLPP::Renderer > renderer, + std::shared_ptr< SDLPP::Scene > scene ) { TetrisPiece retPiece{}; auto color = "#FFFF00"; auto outline = "#AAAA00"; - retPiece.addPiece(createTetrisBlock(0.42, 0.16, color, outline, renderer, scene), -1, 0); - retPiece.addPiece(createTetrisBlock(0.46, 0.16, color, outline, renderer, scene), 0, 0); - retPiece.addPiece(createTetrisBlock(0.5, 0.16, color, outline, renderer, scene), 1, 0); - retPiece.addPiece(createTetrisBlock(0.54, 0.16, color, outline, renderer, scene), 2, 0); - retPiece.setDefPos(0.5, 0.16); + retPiece.addPiece( + createTetrisBlock( 0.42, 0.16, color, outline, renderer, scene ), -1, + 0 ); + retPiece.addPiece( + createTetrisBlock( 0.46, 0.16, color, outline, renderer, scene ), 0, + 0 ); + retPiece.addPiece( + createTetrisBlock( 0.5, 0.16, color, outline, renderer, scene ), 1, 0 ); + retPiece.addPiece( + createTetrisBlock( 0.54, 0.16, color, outline, renderer, scene ), 2, + 0 ); + retPiece.setDefPos( 0.5, 0.16 ); return retPiece; } -TetrisPiece tetrisLLeft(std::shared_ptr renderer, std::shared_ptr scene) { +TetrisPiece tetrisLLeft( std::shared_ptr< SDLPP::Renderer > renderer, + std::shared_ptr< SDLPP::Scene > scene ) { TetrisPiece retPiece{}; auto color = "#00FFFF"; auto outline = "#00AAAA"; - retPiece.addPiece(createTetrisBlock(0.46, 0.16, color, outline, renderer, scene), 0, -1); - retPiece.addPiece(createTetrisBlock(0.46, 0.20, color, outline, renderer, scene), 0, 0); - retPiece.addPiece(createTetrisBlock(0.5, 0.20, color, outline, renderer, scene), 1, 0); - retPiece.addPiece(createTetrisBlock(0.54, 0.20, color, outline, renderer, scene), 2, 0); - retPiece.setDefPos(0.5, 0.16); + retPiece.addPiece( + createTetrisBlock( 0.46, 0.16, color, outline, renderer, scene ), 0, + -1 ); + retPiece.addPiece( + createTetrisBlock( 0.46, 0.20, color, outline, renderer, scene ), 0, + 0 ); + retPiece.addPiece( + createTetrisBlock( 0.5, 0.20, color, outline, renderer, scene ), 1, 0 ); + retPiece.addPiece( + createTetrisBlock( 0.54, 0.20, color, outline, renderer, scene ), 2, + 0 ); + retPiece.setDefPos( 0.5, 0.16 ); return retPiece; } -TetrisPiece tetrisZLeft(std::shared_ptr renderer, std::shared_ptr scene) { +TetrisPiece tetrisZLeft( std::shared_ptr< SDLPP::Renderer > renderer, + std::shared_ptr< SDLPP::Scene > scene ) { TetrisPiece retPiece{}; auto color = "#FFFFFF"; auto outline = "#AAAAAA"; - retPiece.addPiece(createTetrisBlock(0.46, 0.16, color, outline, renderer, scene), -1, 0); - retPiece.addPiece(createTetrisBlock(0.5, 0.16, color, outline, renderer, scene), 0, 0); - retPiece.addPiece(createTetrisBlock(0.5, 0.20, color, outline, renderer, scene), 0, 1); - retPiece.addPiece(createTetrisBlock(0.54, 0.20, color, outline, renderer, scene), 1, 1); - retPiece.setDefPos(0.5, 0.16); + retPiece.addPiece( + createTetrisBlock( 0.46, 0.16, color, outline, renderer, scene ), -1, + 0 ); + retPiece.addPiece( + createTetrisBlock( 0.5, 0.16, color, outline, renderer, scene ), 0, 0 ); + retPiece.addPiece( + createTetrisBlock( 0.5, 0.20, color, outline, renderer, scene ), 0, 1 ); + retPiece.addPiece( + createTetrisBlock( 0.54, 0.20, color, outline, renderer, scene ), 1, + 1 ); + retPiece.setDefPos( 0.5, 0.16 ); return retPiece; } -std::vector, std::shared_ptr)> tetrisFunctions = { - tetrisBrick, - tetrisT, - tetrisLRight, - tetrisZRight, - tetrisLine, - tetrisLLeft, - tetrisZLeft, -}; +std::vector< TetrisPiece ( * )( std::shared_ptr< SDLPP::Renderer >, + std::shared_ptr< SDLPP::Scene > ) > + tetrisFunctions = { + tetrisBrick, tetrisT, tetrisLRight, tetrisZRight, + tetrisLine, tetrisLLeft, tetrisZLeft, + }; -void addStuff(SDLPP::Scene &scene, std::shared_ptr &r) { - auto bg = std::make_shared(0,0,10,10,r,"#101090FF", true); - bg->setPermanent(true); - scene.addObject(bg); - auto left_barrier = std::make_shared(0.28,0,0.02,1,r,"#FF000080", true); +void addStuff( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer > &r ) { + auto bg = std::make_shared< SDLPP::RectangleRender >( 0, 0, 10, 10, r, + "#101090FF", true ); + bg->setPermanent( true ); + scene.addObject( bg ); + auto left_barrier = std::make_shared< SDLPP::RectangleRender >( + 0.28, 0, 0.02, 1, r, "#FF000080", true ); left_barrier->centerX(); - scene.addObject(left_barrier); - auto right_barrier = std::make_shared(0.7,0,0.02,1,r,"#FF000080", true); + scene.addObject( left_barrier ); + auto right_barrier = std::make_shared< SDLPP::RectangleRender >( + 0.7, 0, 0.02, 1, r, "#FF000080", true ); right_barrier->centerX(); - scene.addObject(right_barrier); - auto bottom_barrier = std::make_shared(0.28,1,0.44,0.02,r,"#FF000080", true); + scene.addObject( right_barrier ); + auto bottom_barrier = std::make_shared< SDLPP::RectangleRender >( + 0.28, 1, 0.44, 0.02, r, "#FF000080", true ); bottom_barrier->centerX(); - scene.addObject(bottom_barrier); - auto tetris = std::make_shared(0.4, 0, 0.2, 0.1, r, *font, "TETRIS", "FFFFFF", "000000", 5); + scene.addObject( bottom_barrier ); + auto tetris = std::make_shared< SDLPP::TextRenderer >( + 0.4, 0, 0.2, 0.1, r, *font, "TETRIS", "FFFFFF", "000000", 5 ); tetris->centerX(); - scene.addObject(tetris); - auto next = std::make_shared(0.8, 0.35, 0.2, 0.1, r, *font, "NEXT", "FFFFFF", "000000", 5, SDLPP_TEXT_CENTER); + scene.addObject( tetris ); + auto next = std::make_shared< SDLPP::TextRenderer >( + 0.8, 0.35, 0.2, 0.1, r, *font, "NEXT", "FFFFFF", "000000", 5, + SDLPP_TEXT_CENTER ); next->centerX(); - scene.addObject(next); + scene.addObject( next ); double posy = 1; - auto gameover = std::make_shared(0.5,0,0,0.195, r); - auto gameover_collision = SDLPP::Rect(-1,0,-1,1); + auto gameover = + std::make_shared< SDLPP::RectangleRender >( 0.5, 0, 0, 0.195, r ); + auto gameover_collision = SDLPP::Rect( -1, 0, -1, 1 ); gameover_collision.setInfinite(); - gameover->addCollision(gameover_collision); - gameover->setId(GAME_OVER); - gameover->setColiderColor("FF0000"); - scene.addObject(gameover); - auto score_text = std::make_shared(0.8, 0.1, 0.2, 0.1, r, *font, "SCORE", "#FFFFFF", "#000000", 5, SDLPP_TEXT_CENTER); + gameover->addCollision( gameover_collision ); + gameover->setId( GAME_OVER ); + gameover->setColiderColor( "FF0000" ); + scene.addObject( gameover ); + auto score_text = std::make_shared< SDLPP::TextRenderer >( + 0.8, 0.1, 0.2, 0.1, r, *font, "SCORE", "#FFFFFF", "#000000", 5, + SDLPP_TEXT_CENTER ); score_text->centerX(); - scene.addObject(score_text); + scene.addObject( score_text ); - score_texture = std::make_shared(0.8, 0.2, 0.2, 0.1, r, *font, std::to_string(score), "FFFFFF", "000000", 5, SDLPP_TEXT_TOP); + score_texture = std::make_shared< SDLPP::TextRenderer >( + 0.8, 0.2, 0.2, 0.1, r, *font, std::to_string( score ), "FFFFFF", + "000000", 5, SDLPP_TEXT_TOP ); score_texture->centerX(); - scene.addObject(score_texture); - for(int i = 0; i < 20; i++) { + scene.addObject( score_texture ); + for ( int i = 0; i < 20; i++ ) { posy -= 0.04; - auto colider = std::make_shared(0.3, posy, 0.04, 0.04, r); - auto colider_colider = SDLPP::Rect(-1,0.1,-1,0.8); + auto colider = std::make_shared< SDLPP::RectangleRender >( + 0.3, posy, 0.04, 0.04, r ); + auto colider_colider = SDLPP::Rect( -1, 0.1, -1, 0.8 ); colider_colider.setInfinite(); - colider->addCollision(colider_colider); - colider->setId(COLIDER_ID); - line_coliders.push_back(colider); - scene.addObject(colider); + colider->addCollision( colider_colider ); + colider->setId( COLIDER_ID ); + line_coliders.push_back( colider ); + scene.addObject( colider ); } } void updateScore() { - score_texture->setText(*font, std::to_string(score), "#FFFFFF", "#000000", 5); + score_texture->setText( *font, std::to_string( score ), "#FFFFFF", + "#000000", 5 ); } -void addPause(SDLPP::Scene &scene, std::shared_ptr &r) { - auto bg = std::make_shared(0,0,10,10,r,"#00000080", true); - bg->setId(123); - bg->setPermanent(true); - scene.addObject(bg); - auto y = std::make_shared(0.25, 0.1, 0.5, 0.3, r); - y->setText(*font, "PAUSED", "#FFFFFF", "#000000", 5); - y->setId(0); +void addPause( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer > &r ) { + auto bg = std::make_shared< SDLPP::RectangleRender >( 0, 0, 10, 10, r, + "#00000080", true ); + bg->setId( 123 ); + bg->setPermanent( true ); + scene.addObject( bg ); + auto y = std::make_shared< SDLPP::TextRenderer >( 0.25, 0.1, 0.5, 0.3, r ); + y->setText( *font, "PAUSED", "#FFFFFF", "#000000", 5 ); + y->setId( 0 ); y->centerX(); - scene.addObject(y); - auto resume = std::make_shared(0.4, 0.5, 0.2, 0.1, r); - resume->setText(*font, "Resume", "#FFFFFF", "#000000", 5); - resume->setColor("#FFFFFF40"); + scene.addObject( y ); + auto resume = + std::make_shared< SDLPP::TextRenderer >( 0.4, 0.5, 0.2, 0.1, r ); + resume->setText( *font, "Resume", "#FFFFFF", "#000000", 5 ); + resume->setColor( "#FFFFFF40" ); resume->centerX(); - scene.addObject(resume); - pause_options.push_back(resume); - auto quit = std::make_shared(0.4, 0.7, 0.2, 0.1, r); - quit->setText(*font, "Quit Game", "#FFFFFF", "#000000", 5); + scene.addObject( resume ); + pause_options.push_back( resume ); + auto quit = + std::make_shared< SDLPP::TextRenderer >( 0.4, 0.7, 0.2, 0.1, r ); + quit->setText( *font, "Quit Game", "#FFFFFF", "#000000", 5 ); quit->centerX(); - scene.addObject(quit); - pause_options.push_back(quit); + scene.addObject( quit ); + pause_options.push_back( quit ); } void quitGame() { @@ -290,181 +366,180 @@ void quitGame() { quit = true; } -void handleKeyDown(SDL_Keycode key, SDLPP::Scene &scene) { +void handleKeyDown( SDL_Keycode key, SDLPP::Scene &scene ) { bool crash = false; - std::lock_guard guard(movement_mutex); - switch(key) { - case SDLK_ESCAPE: { - pause = true; - pause_scene->updateSizeAndPosition(); - std::thread pauseThread(doInputPause); - pauseThread.detach(); - } - break; - case SDLK_LEFT: - case SDLK_a: - for(auto &x : cur_object.getObjects()) { + std::lock_guard< std::mutex > guard( movement_mutex ); + switch ( key ) { + case SDLK_ESCAPE: { + pause = true; + pause_scene->updateSizeAndPosition(); + std::thread pauseThread( doInputPause ); + pauseThread.detach(); + } break; + case SDLK_LEFT: + case SDLK_a: + for ( auto &x : cur_object.getObjects() ) { + auto pos = x->getPos(); + // 0.31 because doubles + if ( pos.first < 0.31 ) + crash = true; + x->setPos( pos.first - 0.04, pos.second ); + } + for ( auto &x : cur_object.getObjects() ) { + auto collisions = scene.getCollisions( *x, { BRICK_ID } ); + if ( collisions.size() > 1 ) + crash = true; + } + if ( crash ) { + for ( auto &x : cur_object.getObjects() ) { auto pos = x->getPos(); - // 0.31 because doubles - if(pos.first < 0.31) - crash = true; - x->setPos(pos.first - 0.04, pos.second); + x->setPos( pos.first + 0.04, pos.second ); } - for(auto &x : cur_object.getObjects()) { - auto collisions = scene.getCollisions(*x, {BRICK_ID}); - if(collisions.size() > 1) - crash = true; + } + break; + case SDLK_RIGHT: + case SDLK_d: + for ( auto &x : cur_object.getObjects() ) { + auto pos = x->getPos(); + // 0.65 because doubles + if ( pos.first > 0.65 ) { + crash = true; } - if(crash) { - for(auto &x : cur_object.getObjects()) { - auto pos = x->getPos(); - x->setPos(pos.first + 0.04, pos.second); - } + x->setPos( pos.first + 0.04, pos.second ); + } + for ( auto &x : cur_object.getObjects() ) { + auto collisions = scene.getCollisions( *x, { BRICK_ID } ); + if ( collisions.size() > 1 ) { + crash = true; } - break; - case SDLK_RIGHT: - case SDLK_d: - for(auto &x : cur_object.getObjects()) { + } + if ( crash ) { + for ( auto &x : cur_object.getObjects() ) { auto pos = x->getPos(); - // 0.65 because doubles - if(pos.first > 0.65) { - crash = true; - } - x->setPos(pos.first + 0.04, pos.second); + x->setPos( pos.first - 0.04, pos.second ); } - for(auto &x : cur_object.getObjects()) { - auto collisions = scene.getCollisions(*x, {BRICK_ID}); - if(collisions.size() > 1) { - crash = true; - } - } - if(crash) { - for(auto &x : cur_object.getObjects()) { - auto pos = x->getPos(); - x->setPos(pos.first - 0.04, pos.second); - } - } - break; - case SDLK_DOWN: - case SDLK_s: - cur_object.startDescend(); - break; - case SDLK_UP: - case SDLK_w: - cur_object.rotate(); - break; - case SDLK_r: - scene.getRenderer().setRenderColiders(!scene.getRenderer().getRenderColiders()); - default: - break; + } + break; + case SDLK_DOWN: + case SDLK_s: + cur_object.startDescend(); + break; + case SDLK_UP: + case SDLK_w: + cur_object.rotate(); + break; + case SDLK_r: + scene.getRenderer().setRenderColiders( + !scene.getRenderer().getRenderColiders() ); + default: + break; } } -void handleKeyUp(SDL_Keycode key) { - if(key == SDLK_DOWN || key == SDLK_s) { +void handleKeyUp( SDL_Keycode key ) { + if ( key == SDLK_DOWN || key == SDLK_s ) { cur_object.stopDescend(); } } -void handleKeyDownPause(SDL_Keycode key) { - switch(key) { - case SDLK_ESCAPE: { - pause = false; - active_scene->setPrevTicks(SDL_GetTicks()); - std::thread inputThread(doInput, active_scene); - inputThread.detach(); - } - break; - case SDLK_r: - active_scene->getRenderer().setRenderColiders(!active_scene->getRenderer().getRenderColiders()); - break; - case SDLK_s: - case SDLK_DOWN: - pause_options[pause_select]->unsetColor(); - pause_select++; - if(pause_select > pause_max) - pause_select = 0; - pause_options[pause_select]->setColor("FFFFFF40"); - break; - case SDLK_w: - case SDLK_UP: - pause_options[pause_select]->unsetColor(); - pause_select--; - if(pause_select < 0) - pause_select = pause_max; - pause_options[pause_select]->setColor("FFFFFF40"); - break; - case SDLK_RETURN: - switch(pause_select) { - case 0:{ - pause = false; - active_scene->setPrevTicks(SDL_GetTicks()); - std::thread inputThread(doInput, active_scene); - inputThread.detach(); - } - break; - case 1: - quitGame(); - default: - break; - } +void handleKeyDownPause( SDL_Keycode key ) { + switch ( key ) { + case SDLK_ESCAPE: { + pause = false; + active_scene->setPrevTicks( SDL_GetTicks() ); + std::thread inputThread( doInput, active_scene ); + inputThread.detach(); + } break; + case SDLK_r: + active_scene->getRenderer().setRenderColiders( + !active_scene->getRenderer().getRenderColiders() ); + break; + case SDLK_s: + case SDLK_DOWN: + pause_options[pause_select]->unsetColor(); + pause_select++; + if ( pause_select > pause_max ) + pause_select = 0; + pause_options[pause_select]->setColor( "FFFFFF40" ); + break; + case SDLK_w: + case SDLK_UP: + pause_options[pause_select]->unsetColor(); + pause_select--; + if ( pause_select < 0 ) + pause_select = pause_max; + pause_options[pause_select]->setColor( "FFFFFF40" ); + break; + case SDLK_RETURN: + switch ( pause_select ) { + case 0: { + pause = false; + active_scene->setPrevTicks( SDL_GetTicks() ); + std::thread inputThread( doInput, active_scene ); + inputThread.detach(); + } break; + case 1: + quitGame(); default: break; + } + default: + break; } } -void pollEvents(SDLPP::Scene &scene) { +void pollEvents( SDLPP::Scene &scene ) { SDL_Event event; - while( SDL_PollEvent( &event ) != 0 ) { - switch(event.type) { - case SDL_QUIT: - quitGame(); - break; - case SDL_KEYDOWN: - if( !event.key.repeat ) - handleKeyDown(event.key.keysym.sym, scene); - break; - case SDL_KEYUP: - handleKeyUp(event.key.keysym.sym); - break; - case SDL_WINDOWEVENT: - if(event.window.event == SDL_WINDOWEVENT_RESIZED) - scene.updateSizeAndPosition(); - default: - break; + while ( SDL_PollEvent( &event ) != 0 ) { + switch ( event.type ) { + case SDL_QUIT: + quitGame(); + break; + case SDL_KEYDOWN: + if ( !event.key.repeat ) + handleKeyDown( event.key.keysym.sym, scene ); + break; + case SDL_KEYUP: + handleKeyUp( event.key.keysym.sym ); + break; + case SDL_WINDOWEVENT: + if ( event.window.event == SDL_WINDOWEVENT_RESIZED ) + scene.updateSizeAndPosition(); + default: + break; } } } void pollEventsPause() { SDL_Event event; - while( SDL_PollEvent( &event ) != 0 ) { - switch(event.type) { - case SDL_QUIT: - quitGame(); - break; - case SDL_KEYDOWN: - if( !event.key.repeat ) - handleKeyDownPause(event.key.keysym.sym); - break; - case SDL_WINDOWEVENT: - if(event.window.event == SDL_WINDOWEVENT_RESIZED) { - active_scene->updateSizeAndPosition(); - pause_scene->updateSizeAndPosition(); - } - default: - break; + while ( SDL_PollEvent( &event ) != 0 ) { + switch ( event.type ) { + case SDL_QUIT: + quitGame(); + break; + case SDL_KEYDOWN: + if ( !event.key.repeat ) + handleKeyDownPause( event.key.keysym.sym ); + break; + case SDL_WINDOWEVENT: + if ( event.window.event == SDL_WINDOWEVENT_RESIZED ) { + active_scene->updateSizeAndPosition(); + pause_scene->updateSizeAndPosition(); + } + default: + break; } } } -void moveThem(std::shared_ptr scene, int ticks) { - std::lock_guard guard(movement_mutex); +void moveThem( std::shared_ptr< SDLPP::Scene > scene, int ticks ) { + std::lock_guard< std::mutex > guard( movement_mutex ); ticks_till_fall -= ticks; - if(cur_object.isDescending()) + if ( cur_object.isDescending() ) ticks_till_descend -= ticks; - if(ticks_till_fall > 0) { - if(cur_object.isDescending() && ticks_till_descend <= 0) { + if ( ticks_till_fall > 0 ) { + if ( cur_object.isDescending() && ticks_till_descend <= 0 ) { ticks_till_descend = 50; goto fall; } @@ -472,29 +547,29 @@ void moveThem(std::shared_ptr scene, int ticks) { } ticks_till_fall = 500; fall: - for(auto &x : cur_object.getObjects()) { + for ( auto &x : cur_object.getObjects() ) { auto pos = x->getPos(); - x->setPos(pos.first, pos.second + 0.04); + x->setPos( pos.first, pos.second + 0.04 ); } bool fell = false; - for(auto &x : cur_object.getObjects()) { - auto collisions = scene->getCollisions(*x, {BRICK_ID}); - if(collisions.size() > 1) { + for ( auto &x : cur_object.getObjects() ) { + auto collisions = scene->getCollisions( *x, { BRICK_ID } ); + if ( collisions.size() > 1 ) { fell = true; break; } - if(x->getPos().second >= 1) { + if ( x->getPos().second >= 1 ) { fell = true; break; } } - if(fell) { - for(auto &x : cur_object.getObjects()) { + if ( fell ) { + for ( auto &x : cur_object.getObjects() ) { auto pos = x->getPos(); - x->setPos(pos.first, pos.second - 0.04); + x->setPos( pos.first, pos.second - 0.04 ); } - for(auto &block : cur_object.getObjects()) { - if(scene->getCollisions(*block, {GAME_OVER}).size() > 0) { + for ( auto &block : cur_object.getObjects() ) { + if ( scene->getCollisions( *block, { GAME_OVER } ).size() > 0 ) { std::cout << "You lost" << std::endl; quitGame(); } @@ -503,42 +578,42 @@ fall: } } -void doInput(std::shared_ptr scene) { +void doInput( std::shared_ptr< SDLPP::Scene > scene ) { FPSmanager gFPS; - SDL_initFramerate(&gFPS); - SDL_setFramerate(&gFPS, 200); + SDL_initFramerate( &gFPS ); + SDL_setFramerate( &gFPS, 200 ); auto base = SDL_GetTicks(); - while(!quit && !pause) { + while ( !quit && !pause ) { base = SDL_GetTicks(); - SDL_framerateDelay(&gFPS); - pollEvents(*scene); + SDL_framerateDelay( &gFPS ); + pollEvents( *scene ); scene->movement(); - if(cur_object.getObjects().size() != 0) { - moveThem(scene, SDL_GetTicks() - base); + if ( cur_object.getObjects().size() != 0 ) { + moveThem( scene, SDL_GetTicks() - base ); continue; } - std::lock_guard guard(movement_mutex); - for( auto &colider : line_coliders ) { - auto collisions = scene->getCollisions(*colider, {BRICK_ID}); - while(collisions.size() == 10) { + std::lock_guard< std::mutex > guard( movement_mutex ); + for ( auto &colider : line_coliders ) { + auto collisions = scene->getCollisions( *colider, { BRICK_ID } ); + while ( collisions.size() == 10 ) { score += 10; -// updateScore(); + // updateScore(); update_score = true; - for(auto &col : collisions) { + for ( auto &col : collisions ) { col->destroy(); } auto colider_y = colider->getPos().second; - for(auto &elem : scene->getObjects()) { - if(elem->getId() != BRICK_ID) + for ( auto &elem : scene->getObjects() ) { + if ( elem->getId() != BRICK_ID ) continue; auto pos = elem->getPos(); - if(pos.second < colider_y) { - elem->setPos(pos.first, pos.second + 0.04); + if ( pos.second < colider_y ) { + elem->setPos( pos.first, pos.second + 0.04 ); } } using namespace std::chrono_literals; - std::this_thread::sleep_for(0.1s); - collisions = scene->getCollisions(*colider, {BRICK_ID}); + std::this_thread::sleep_for( 0.1s ); + collisions = scene->getCollisions( *colider, { BRICK_ID } ); } } } @@ -546,67 +621,70 @@ void doInput(std::shared_ptr scene) { void doInputPause() { FPSmanager gFPS; - SDL_initFramerate(&gFPS); - SDL_setFramerate(&gFPS, 200); - while(pause) { - SDL_framerateDelay(&gFPS); + SDL_initFramerate( &gFPS ); + SDL_setFramerate( &gFPS, 200 ); + while ( pause ) { + SDL_framerateDelay( &gFPS ); pollEventsPause(); - if(!pause) + if ( !pause ) break; } } int main() { SDLPP::init(); - SDLPP::Window w("Tetris clone!"); - auto renderer = std::make_shared(w); + SDLPP::Window w( "Tetris clone!" ); + auto renderer = std::make_shared< SDLPP::Renderer >( w ); active_renderer = renderer; - renderer->setBlendMode(SDL_BLENDMODE_BLEND); - auto main_scene = std::make_shared(renderer); + renderer->setBlendMode( SDL_BLENDMODE_BLEND ); + auto main_scene = std::make_shared< SDLPP::Scene >( renderer ); active_scene = main_scene; - font = std::make_shared("testfont.ttf", 96); - addStuff(*main_scene, renderer); + font = std::make_shared< SDLPP::Font >( "testfont.ttf", 96 ); + addStuff( *main_scene, renderer ); - pause_scene = std::make_shared(renderer); - addPause(*pause_scene, renderer); + pause_scene = std::make_shared< SDLPP::Scene >( renderer ); + addPause( *pause_scene, renderer ); int base = SDL_GetTicks(); int frames = 0; - std::srand(std::time(nullptr)); + std::srand( std::time( nullptr ) ); FPSmanager gFPS; - SDL_initFramerate(&gFPS); - SDL_setFramerate(&gFPS, 60); - std::thread inputThread(doInput, main_scene); + SDL_initFramerate( &gFPS ); + SDL_setFramerate( &gFPS, 60 ); + std::thread inputThread( doInput, main_scene ); inputThread.detach(); - next_object = tetrisFunctions[std::rand()/((RAND_MAX + 1u)/7)](renderer, main_scene); - next_object.setPos(0.9, 0.5); - while( !quit ) { - SDL_framerateDelay(&gFPS); - if(cur_object.getObjects().size() != 0) { + next_object = tetrisFunctions[std::rand() / ( ( RAND_MAX + 1u ) / 7 )]( + renderer, main_scene ); + next_object.setPos( 0.9, 0.5 ); + while ( !quit ) { + SDL_framerateDelay( &gFPS ); + if ( cur_object.getObjects().size() != 0 ) { ticks_till_next = 1500; } else { ticks_till_next -= SDL_GetTicks() - base; - if(ticks_till_next <= 0 && cur_object.getObjects().size() == 0) { - std::lock_guard guard(movement_mutex); + if ( ticks_till_next <= 0 && cur_object.getObjects().size() == 0 ) { + std::lock_guard< std::mutex > guard( movement_mutex ); cur_object = next_object; - cur_object.setPos(0.5, 0.16); - next_object = tetrisFunctions[std::rand()/((RAND_MAX + 1u)/7)](renderer, main_scene); - next_object.setPos(0.9, 0.5); + cur_object.setPos( 0.5, 0.16 ); + next_object = + tetrisFunctions[std::rand() / ( ( RAND_MAX + 1u ) / 7 )]( + renderer, main_scene ); + next_object.setPos( 0.9, 0.5 ); } } - if(update_score) { + if ( update_score ) { updateScore(); update_score = false; } main_scene->renderScene(); - if(pause) { - pause_scene->renderScene(false); + if ( pause ) { + pause_scene->renderScene( false ); } main_scene->presentScene(); frames++; - if(SDL_GetTicks() - base >= 1000) { + if ( SDL_GetTicks() - base >= 1000 ) { base = SDL_GetTicks(); std::cout << "FPS: " << frames << std::endl; frames = 0;