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 )
        : LineRenderer( { { x1, y1 }, { x2, y2 } }, r ) {}
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, color ) {}
LineRenderer::LineRenderer( const Line< double > &line,
                            const std::shared_ptr< Renderer > &r )
        : RenderObject( r ) {
    original = current = line;
    updateSizeAndPosition();
}
LineRenderer::LineRenderer( const Line< double > &line,
                            const std::shared_ptr< Renderer > &r,
                            const std::string &color )
        : LineRenderer( line, 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_line.getStart().getX(),
            pixel_line.getStart().getY(), pixel_line.getEnd().getX(),
            pixel_line.getEnd().getY() );
    }
    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;

    original.add( { addx, addy } );

    custom_move( ticks );

    updateSizeAndPosition();
}
void LineRenderer::setPos( double x, double y ) {
    auto diffx = original.getEnd().getX() - original.getStart().getX();
    auto diffy = original.getEnd().getY() - original.getStart().getY();
    original = { { x, y }, { x + diffx, y + diffy } };
    updateSizeAndPosition();
}
void LineRenderer::setPos( const std::pair< double, double > &pos ) {
    setPos( pos.first, pos.second );
}
void LineRenderer::setPos( const Vec2D<double> &vec ) {
    setPos( vec.getX(), vec.getY() );
}
Vec2D< double > LineRenderer::getPos() const {
    return original.getStart();
}
int LineRenderer::leftmost() {
    return pixel_line.getStart().getX() < pixel_line.getEnd().getX()
               ? pixel_line.getStart().getX()
               : pixel_line.getEnd().getX();
}
int LineRenderer::topmost() {
    return pixel_line.getStart().getY() < pixel_line.getEnd().getY()
               ? pixel_line.getStart().getY()
               : pixel_line.getEnd().getY();
}
int LineRenderer::rightmost() {
    return pixel_line.getStart().getX() > pixel_line.getEnd().getX()
               ? pixel_line.getStart().getX()
               : pixel_line.getEnd().getX();
}
int LineRenderer::bottommost() {
    return pixel_line.getStart().getY() > pixel_line.getEnd().getY()
               ? pixel_line.getStart().getY()
               : pixel_line.getEnd().getY();
}
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_line = Line< int >(
        Vec2D< int >( std::round( current.getStart().getX() * dimension ),
                      std::round( current.getStart().getY() * dimension ) ),
        Vec2D< int >( std::round( current.getEnd().getX() * dimension ),
                      std::round( current.getEnd().getY() * 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< Vec2D<double>, Vec2D<double> >
LineRenderer::getDoubleRect() const {
    return { original.getStart(), original.getEnd() - original.getStart() };
}

void LineRenderer::updateXY() {
    if ( !centerx ) {
        current = original;
        return;
    }
    auto width = renderer->getWidth();
    auto height = renderer->getHeight();
    double x1_, x2_, y1_, y2_;
    if ( width > height ) {
        auto multiplier =
            static_cast< double >( width ) / static_cast< double >( height );
        x1_ = original.getStart().getX() + static_cast< double >( multiplier - 1 ) / 2;
        x2_ = original.getEnd().getX() + static_cast< double >( multiplier - 1 ) / 2;
    } else {
        x1_ = original.getStart().getX();
        x2_ = original.getEnd().getX();
    }
    y1_ = original.getStart().getY();
    y2_ = original.getEnd().getY();
    current = {{x1_, y1_}, {x2_, y2_}};
}
} // namespace SDLPP