game/sdlpp/sdlpp_linerenderer.cpp

#include <cmath>
#include "sdlpp_linerenderer.hpp"

namespace SDLPP {
LineRenderer::LineRenderer( double x1, double y1, double x2, double y2,
                            const std::shared_ptr< Renderer > &r )
        : RenderObject( r ) {
    og_x1 = x1_ = x1;
    og_y1 = y1_ = y1;
    og_x2 = x2_ = x2;
    og_y2 = y2_ = y2;
    updateSizeAndPosition();
}
LineRenderer::LineRenderer( double x1, double y1, double x2, double y2,
                            const std::shared_ptr< Renderer > &r,
                            const std::string &color )
        : LineRenderer( x1, y1, x2, y2, r ) {
    setColor( color );
}
void LineRenderer::setColor( const std::string &color ) {
    _color = getColorsHEX( color );
}
void LineRenderer::render() {
    if ( !getHidden() ) {
        SDL_SetRenderDrawColor(
            renderer->getRendererPtr(), std::get< 0 >( _color ),
            std::get< 1 >( _color ), std::get< 2 >( _color ),
            std::get< 3 >( _color ) );
        SDL_RenderDrawLine( renderer->getRendererPtr(), pixel_x1, pixel_y1,
                            pixel_x2, pixel_y2 );
    }
    if ( hasCollisions() && renderer->getRenderColiders() && !getHidden() ) {
        for ( const auto &col : getCollisions() )
            col->render( *renderer, colider_color );
    }
}
void LineRenderer::move( int ticks ) {
    if ( permanent )
        return;
    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_x1 += addx;
    og_x2 += addx;
    og_y1 += addy;
    og_y2 += addy;

    custom_move( ticks );

    updateSizeAndPosition();
}
void LineRenderer::setPos( double x, double y ) {
    auto diffx = og_x2 - og_x1;
    auto diffy = og_y2 - og_y1;
    og_x1 = x;
    og_y1 = y;
    og_x2 = og_x1 + diffx;
    og_y2 = og_y1 + diffy;
    updateSizeAndPosition();
}
void LineRenderer::setPos( const std::pair< double, double > &pos ) {
    setPos( pos.first, pos.second );
}
std::pair< double, double > LineRenderer::getPos() const {
    return { og_x1, og_y1 };
}
int LineRenderer::leftmost() {
    return pixel_x1 < pixel_x2 ? pixel_x1 : pixel_x2;
}
int LineRenderer::topmost() {
    return pixel_y1 < pixel_y2 ? pixel_y1 : pixel_y2;
}
int LineRenderer::rightmost() {
    return pixel_x1 > pixel_x2 ? pixel_x1 : pixel_x2;
}
int LineRenderer::bottommost() {
    return pixel_y1 > pixel_y2 ? pixel_y1 : pixel_y2;
}
int LineRenderer::collisionPushX() {
    return leftmost();
}
int LineRenderer::collisionPushY() {
    return topmost();
}
int LineRenderer::collisionWidth() {
    return rightmost() - leftmost();
}
int LineRenderer::collisionHeight() {
    return bottommost() - topmost();
}
void LineRenderer::updateSizeAndPosition() {
    updateXY();
    auto dimension = renderer->getSmallerSide();
    pixel_x1 = std::round( x1_ * dimension );
    pixel_x2 = std::round( x2_ * dimension );
    pixel_y1 = std::round( y1_ * dimension );
    pixel_y2 = std::round( y2_ * dimension );
    for ( auto &x : collisions ) {
        x->updateCollision( collisionPushX(), collisionPushY(),
                            collisionWidth(), collisionHeight() );
    }
}
void LineRenderer::centerX() {
    centerx = true;
    updateSizeAndPosition();
}
std::shared_ptr< RenderObject > LineRenderer::copySelf() {
    auto ret = std::make_shared< LineRenderer >( *this );
    copyTo(ret);
    return ret;
}
void LineRenderer::copyTo(std::shared_ptr<RenderObject> other) {
    RenderObject::copyTo(other);
}

SDL_Rect LineRenderer::getRect() {
    return { leftmost(), topmost(), rightmost() - leftmost(),
             bottommost() - topmost() };
}
std::pair< std::pair< double, double >, std::pair< double, double > >
LineRenderer::getDoubleRect() const {
    return { { og_x1, og_y1 }, { og_x2 - og_x1, og_y2 - og_y1 } };
}

void LineRenderer::updateXY() {
    if ( !centerx ) {
        x1_ = og_x1;
        y1_ = og_y1;
        x2_ = og_x2;
        y2_ = og_y2;
        return;
    }
    auto width = renderer->getWidth();
    auto height = renderer->getHeight();
    if ( width > height ) {
        auto multiplier =
            static_cast< double >( width ) / static_cast< double >( height );
        x1_ = og_x1 + static_cast< double >( multiplier - 1 ) / 2;
        x2_ = og_x2 + static_cast< double >( multiplier - 1 ) / 2;
    } else {
        x1_ = og_x1;
        x2_ = og_x2;
    }
    y1_ = og_y1;
    y2_ = og_y2;
}
} // namespace SDLPP