game/tetris/custom_classes.cpp

#include "custom_classes.hpp"

std::shared_ptr< SDLPP::Texture > TetrisBlock::block_texture = nullptr;
#ifdef FEATURE
const std::vector< SDL_Rect > blockanim = { { 0, 0, 125, 125 },
                                            { 125, 0, 250, 125 },
                                            { 125, 125, 250, 250 },
                                            { 0, 125, 125, 250 } };
#endif

TetrisBlock::TetrisBlock( double x, double y, double w, double h,
                          const std::shared_ptr< SDLPP::Renderer > &r,
                          const std::string &img_or_color, bool is_polygon,
                          int index, std::shared_ptr< SDLPP::Scene > scene,
                          std::vector< int > &bag )
        : RectangleRender( x, y, w, h, r, img_or_color, is_polygon ),
          pieces_bag( bag ) {
    _index = index;
    pieces_bag[_index]--;
    _scene = scene;
    setColors();
    if ( TetrisBlock::block_texture == nullptr ) {
        TetrisBlock::block_texture =
            std::make_shared< SDLPP::Texture >( renderer, "block.png" );
        TetrisBlock::block_texture->setAlpha( 240 );
    }
    if ( g_show_3d )
#ifdef FEATURE
        setTexture( TetrisBlock::block_texture, 0, 0, 125, 125 );
    setAnimationFrames( blockanim );
    setAnimationSpeed( 4 );
#else
        setTexture( TetrisBlock::block_texture );
#endif
}

TetrisBlock::TetrisBlock( const TetrisBlock &other )
        : TetrisBlock( other.getDoubleRect().first.getX(),
                       other.getDoubleRect().first.getY(),
                       other.getDoubleRect().second.getX(),
                       other.getDoubleRect().second.getY(), other.getRenderer(),
                       other.getColor(), true, other._index, other._scene,
                       other.pieces_bag ) {}

TetrisBlock::~TetrisBlock() {
    if ( _index != PIECE_SHADOW )
        pieces_bag[_index]++;
}

std::shared_ptr< SDLPP::RenderObject > TetrisBlock::copySelf() {
    auto ret = std::make_shared< TetrisBlock >( *this );
    copyTo( ret );
    return ret;
}

void TetrisBlock::copyTo( std::shared_ptr< SDLPP::RenderObject > other ) {
    RectangleRender::copyTo( other );
}

std::shared_ptr< TetrisBlock > TetrisBlock::copyInScene() {
    auto ret = std::shared_ptr< TetrisBlock >( new TetrisBlock( *this ) );
    _scene->addObject( ret );
    return ret;
}

bool TetrisBlock::isSamePos( const SDLPP::RenderObject &other ) const {
    auto mypos = getPos();
    auto otherpos = other.getPos();
    auto diff1 = mypos.getX() - otherpos.getX();
    diff1 = ( diff1 < 0 ) * ( -1 ) * diff1 + ( diff1 > 0 ) * diff1;
    auto diff2 = mypos.getY() - otherpos.getY();
    diff2 = ( diff2 < 0 ) * ( -1 ) * diff2 + ( diff2 > 0 ) * diff2;
    return diff1 < 0.0001 && diff2 < 0.0001;
}

void TetrisBlock::specialAction( int code ) {
    switch ( code ) {
    case PIECE_ACTION_UPDATE_COLOR:
        setColors();
        // fallthrough
    case PIECE_ACTION_UPDATE_BLOCK:
        if ( g_show_3d )
#ifdef FEATURE
            setTexture( TetrisBlock::block_texture, 0, 0, 125, 125 );
#else
            setTexture( TetrisBlock::block_texture );
#endif
        else
            unsetTexture();
    default:
        break;
    }
}

void TetrisBlock::turnIntoShadow() {
    setId( SHADOW_ID );
    // shadows don't consume pieces from bag
    pieces_bag[_index]++;
    _index = PIECE_SHADOW;
    setColors();
}

std::string TetrisBlock::getPieceName() {
    switch ( _index ) {
    case PIECE_BRICK:
        return "piece_brick";
    case PIECE_T:
        return "piece_T";
    case PIECE_L_RIGHT:
        return "piece_L_right";
    case PIECE_Z_RIGHT:
        return "piece_Z_right";
    case PIECE_LINE:
        return "piece_line";
    case PIECE_L_LEFT:
        return "piece_L_left";
    case PIECE_Z_LEFT:
        return "piece_Z_left";
    case PIECE_SHADOW:
        return "shadow";
    default:
        break;
    }
    return "";
}

void TetrisBlock::setColors() {
    auto piece_name = getPieceName();
    setColor( colors[piece_name] );
    setOutlineColor( colors[piece_name + "_out"] );
}

TetrisPiece::TetrisPiece() {
    original_pos.reserve( 4 );
}

void TetrisPiece::addPiece( std::shared_ptr< TetrisBlock > 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;
}

void TetrisPiece::rotate() {
    if ( !rotate_allowed )
        return;
    for ( unsigned long i = 0; i < pieces.size(); i++ ) {
        auto &piece = pieces[i];
        auto &positions = pieces_rel_position[i];
        auto piece_position = piece->getPos();
        original_pos[i] = piece_position;
        piece_position +=
            { positions[0] * BLOCK_SIZE - positions[1] * BLOCK_SIZE,
              positions[2] * BLOCK_SIZE - positions[3] * BLOCK_SIZE };
        auto bottom = positions[3];
        auto top = positions[2];
        positions[3] = positions[1];
        positions[2] = positions[0];
        positions[1] = top;
        positions[0] = bottom;
        piece_position +=
            { positions[1] * BLOCK_SIZE - positions[0] * BLOCK_SIZE,
              positions[3] * BLOCK_SIZE - positions[2] * BLOCK_SIZE };
        piece->setPos( piece_position );
    }
}

void TetrisPiece::revert() {
    for ( unsigned long i = 0; i < pieces.size(); i++ ) {
        auto &piece = pieces[i];
        auto &positions = pieces_rel_position[i];
        piece->setPos( original_pos[i] );
        auto top = positions[1];
        auto bottom = positions[0];
        positions[1] = positions[3];
        positions[0] = positions[2];
        positions[2] = top;
        positions[3] = bottom;
    }
}

std::vector< std::shared_ptr< TetrisBlock > > &TetrisPiece::getObjects() {
    return pieces;
}

void TetrisPiece::setPos( double x, double y ) {
    for ( unsigned long i = 0; i < pieces.size(); i++ ) {
        auto &piece = pieces[i];
        auto &positions = pieces_rel_position[i];
        std::pair< double, double > pos = { x, y };
        pos.first -= positions[0] * BLOCK_SIZE;
        pos.first += positions[1] * BLOCK_SIZE;
        pos.second -= positions[2] * BLOCK_SIZE;
        pos.second += positions[3] * BLOCK_SIZE;
        piece->setPos( pos.first, pos.second );
    }
}

void TetrisPiece::setPos( const std::pair< double, double > &pos ) {
    setPos( pos.first, pos.second );
}

void TetrisPiece::setPos( const SDLPP::Vec2D< double > &vec ) {
    setPos( vec.getX(), vec.getY() );
}

SDLPP::Vec2D< double > TetrisPiece::getPos() {
    auto &piece = pieces[0];
    auto &relpositions = pieces_rel_position[0];
    auto pos = piece->getPos();
    pos += { relpositions[0] * BLOCK_SIZE - relpositions[1] * BLOCK_SIZE,
             relpositions[2] * BLOCK_SIZE - relpositions[3] * BLOCK_SIZE };
    return pos;
}

void TetrisPiece::clear() {
    pieces.clear();
    pieces_rel_position.clear();
}

void TetrisPiece::startDescend() {
    descend = true;
}

void TetrisPiece::stopDescend() {
    descend = false;
}

void TetrisPiece::startMovement() {
    userMovement += 1;
}

void TetrisPiece::stopMovement() {
    userMovement -= 1;
}

bool TetrisPiece::isDescending() {
    return descend;
}

bool TetrisPiece::isMoving() {
    return userMovement > 0;
}

bool TetrisPiece::isLeft( const SDLPP::RenderObject &block ) const {
    return isPosition( block, 0 );
}

bool TetrisPiece::isRight( const SDLPP::RenderObject &block ) const {
    return isPosition( block, 1 );
}

void TetrisPiece::movePiece( double x, double y ) {
    for ( auto &block : getObjects() ) {
        auto pos = block->getPos();
        block->setPos( pos + SDLPP::Vec2D< double >( x, y ) );
    }
}

void TetrisPiece::disableRotation() {
    rotate_allowed = false;
}

void TetrisPiece::turnIntoShadow() {
    for ( auto &block : getObjects() )
        block->turnIntoShadow();
    setHidden( !g_show_shadow );
}

std::shared_ptr< TetrisPiece > TetrisPiece::copySelf() {
    auto ret = std::make_shared< TetrisPiece >();
    for ( int i = 0; i < 4; i++ ) {
        auto block = pieces[i]->copyInScene();
        block->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
        ret->addBlockInPos( block, pieces_rel_position[i] );
    }
    if ( !rotate_allowed )
        ret->disableRotation();
    ret->setHidden( _hidden );
    return ret;
}

void TetrisPiece::destroy() {
    for ( auto &x : getObjects() ) {
        x->destroy();
    }
}

void TetrisPiece::addMovement( int x, int y ) {
    movement.first += x;
    movement.second += y;
}

std::pair< int, int > TetrisPiece::getMovement() const {
    return movement;
}

void TetrisPiece::setHidden( bool hidden ) {
    _hidden = hidden;
    for ( auto &x : getObjects() ) {
        x->setHidden( hidden );
    }
}

bool TetrisPiece::getHidden() {
    return _hidden;
}

bool TetrisPiece::isPosition( const SDLPP::RenderObject &block,
                              int pos ) const {
    for ( int i = 0; i < 4; i++ ) {
        if ( pieces[i]->isSamePos( block ) ) {
            return pieces_rel_position[i][pos] != 0;
        }
    }
    return false;
}

void TetrisPiece::resetBlock( int index,
                              std::shared_ptr< TetrisBlock > piece ) {
    piece->setPos( pieces[index]->getPos() );
    pieces[index] = piece;
}

void TetrisPiece::addBlockInPos( std::shared_ptr< TetrisBlock > piece,
                                 const std::vector< int > &relpos ) {
    pieces.push_back( piece );
    pieces_rel_position.push_back( relpos );
}