1251 lines
43 KiB
C++
1251 lines
43 KiB
C++
#include "../sdlpp.hpp"
|
|
#include <thread>
|
|
#include <chrono>
|
|
#include <mutex>
|
|
#include <SDL2/SDL2_framerate.h>
|
|
|
|
#define COLIDER_ID 0x00000001
|
|
#define BRICK_ID 0x00000002
|
|
#define GAME_OVER 0x00000003
|
|
#define SHADOW_ID 0x00000004
|
|
#define BORDER_LEFT_ID 0x00000005
|
|
#define BORDER_RIGHT_ID 0x00000006
|
|
#define FLOOR_ID 0x00000007
|
|
|
|
#define LEFT_BORDER 0.3
|
|
#define RIGHT_BORDER 0.7
|
|
#define BOTTOM_BORDER 1
|
|
#define TOP_BORDER 0.16
|
|
#define BLOCK_SIZE 0.04
|
|
|
|
#define TICKS_TILL_FALL 500
|
|
#define TICKS_TILL_DESCEND 50
|
|
#define TICKS_TILL_MOVE 100
|
|
|
|
#define TETRIS_BRICK 0
|
|
#define TETRIS_T 1
|
|
#define TETRIS_L_RIGHT 2
|
|
#define TETRIS_Z_RIGHT 3
|
|
#define TETRIS_LINE 4
|
|
#define TETRIS_L_LEFT 5
|
|
#define TETRIS_Z_LEFT 6
|
|
|
|
#define PAUSE_PAUSE 1
|
|
#define PAUSE_GAME_OVER 2
|
|
|
|
int pause = 0;
|
|
int pause_select = 0;
|
|
int pause_max = 2;
|
|
int game_over_select = 0;
|
|
int game_over_max = 1;
|
|
int ticks_till_fall = TICKS_TILL_FALL;
|
|
int ticks_till_descend = TICKS_TILL_DESCEND;
|
|
int ticks_till_movement = TICKS_TILL_MOVE;
|
|
std::vector< std::shared_ptr< SDLPP::RectangleRender > > pause_options;
|
|
std::vector< std::shared_ptr< SDLPP::RectangleRender > > game_over_options;
|
|
std::shared_ptr< SDLPP::TextRenderer > score_texture;
|
|
std::shared_ptr< SDLPP::Renderer > active_renderer;
|
|
int score = 0;
|
|
bool update_score = false;
|
|
bool checked_line = false;
|
|
bool wait_for_anim = false;
|
|
|
|
std::vector< int > bag = { 28, 28, 28, 28, 28, 28, 28 };
|
|
|
|
std::shared_ptr< SDLPP::Font > font;
|
|
std::shared_ptr< SDLPP::Scene > active_scene;
|
|
std::shared_ptr< SDLPP::Scene > pause_scene;
|
|
std::shared_ptr< SDLPP::Scene > game_over_scene;
|
|
|
|
class TetrisBlock : public SDLPP::RectangleRender {
|
|
public:
|
|
TetrisBlock() = delete;
|
|
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 )
|
|
: RectangleRender( x, y, w, h, r, img_or_color, is_polygon ) {
|
|
_index = index;
|
|
bag[_index]--;
|
|
_scene = scene;
|
|
}
|
|
TetrisBlock( const TetrisBlock &other ) : TetrisBlock(other.getDoubleRect().first.first,other.getDoubleRect().first.second,other.getDoubleRect().second.first,other.getDoubleRect().second.second,other.getRenderer(), other.getColor(), true, other._index, other._scene) {}
|
|
~TetrisBlock() {
|
|
bag[_index]++;
|
|
}
|
|
virtual std::shared_ptr<RenderObject> copySelf() {
|
|
return std::make_shared<TetrisBlock>(*this);
|
|
}
|
|
std::shared_ptr<TetrisBlock> copyInScene() {
|
|
auto ret = std::shared_ptr<TetrisBlock>(new TetrisBlock(*this));
|
|
_scene->addObject(ret);
|
|
return ret;
|
|
}
|
|
bool isSamePos(const SDLPP::RenderObject &other) const {
|
|
auto mypos = getPos();
|
|
auto otherpos = other.getPos();
|
|
auto diff1 = mypos.first - otherpos.first;
|
|
diff1 = (diff1 < 0) * (-1) * diff1 + (diff1 > 0) * diff1;
|
|
auto diff2 = mypos.second - otherpos.second;
|
|
diff2 = (diff2 < 0) * (-1) * diff2 + (diff2 > 0) * diff2;
|
|
return diff1 < 0.0001 && diff2 < 0.0001;
|
|
}
|
|
|
|
private:
|
|
int _index = 0;
|
|
std::shared_ptr<SDLPP::Scene> _scene;
|
|
};
|
|
|
|
std::shared_ptr< TetrisBlock >
|
|
createTetrisBlock( double x, double y, const std::string &color,
|
|
const std::string &outline, int index,
|
|
std::shared_ptr< SDLPP::Renderer > renderer,
|
|
std::shared_ptr< SDLPP::Scene > scene ) {
|
|
auto ret = std::make_shared< TetrisBlock >( x, y, BLOCK_SIZE, BLOCK_SIZE,
|
|
renderer, color, true, index, scene );
|
|
ret->setOutlineColor( outline );
|
|
ret->addCollision( SDLPP::Rect( 0.1, 0.1, 0.8, 0.8 ) );
|
|
ret->setId( BRICK_ID );
|
|
ret->centerX();
|
|
scene->addObject( ret );
|
|
return ret;
|
|
}
|
|
|
|
class TetrisPiece {
|
|
public:
|
|
TetrisPiece() {
|
|
original_pos.reserve( 4 );
|
|
}
|
|
void 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 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 position = piece->getPos();
|
|
original_pos[i] = position;
|
|
position.first += positions[0] * BLOCK_SIZE;
|
|
position.first -= positions[1] * BLOCK_SIZE;
|
|
position.second += positions[2] * BLOCK_SIZE;
|
|
position.second -= 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;
|
|
position.first -= positions[0] * BLOCK_SIZE;
|
|
position.first += positions[1] * BLOCK_SIZE;
|
|
position.second -= positions[2] * BLOCK_SIZE;
|
|
position.second += positions[3] * BLOCK_SIZE;
|
|
piece->setPos( position.first, position.second );
|
|
}
|
|
}
|
|
void 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].first, original_pos[i].second );
|
|
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 > > &getObjects() {
|
|
return pieces;
|
|
}
|
|
void 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 setPos(const std::pair<double,double> &pos) {
|
|
setPos(pos.first, pos.second);
|
|
}
|
|
std::pair<double, double> getPos() {
|
|
auto &piece = pieces[0];
|
|
auto &relpositions = pieces_rel_position[0];
|
|
auto pos = piece->getPos();
|
|
pos.first += relpositions[0] * BLOCK_SIZE;
|
|
pos.first -= relpositions[1] * BLOCK_SIZE;
|
|
pos.second += relpositions[2] * BLOCK_SIZE;
|
|
pos.second -= relpositions[3] * BLOCK_SIZE;
|
|
return pos;
|
|
}
|
|
void clear() {
|
|
pieces.clear();
|
|
pieces_rel_position.clear();
|
|
}
|
|
void startDescend() {
|
|
descend = true;
|
|
}
|
|
void stopDescend() {
|
|
descend = false;
|
|
}
|
|
void startMovement() {
|
|
userMovement += 1;
|
|
}
|
|
void stopMovement() {
|
|
userMovement -= 1;
|
|
}
|
|
bool isDescending() {
|
|
return descend;
|
|
}
|
|
bool isMoving() {
|
|
return userMovement > 0;
|
|
}
|
|
bool isLeft(const SDLPP::RenderObject &block) const {
|
|
return isPosition(block, 0);
|
|
}
|
|
bool isRight(const SDLPP::RenderObject &block) const {
|
|
return isPosition(block, 1);
|
|
}
|
|
void movePiece(double x, double y) {
|
|
for ( auto &block : getObjects() ) {
|
|
auto pos = block->getPos();
|
|
block->setPos( pos.first + x, pos.second + y );
|
|
}
|
|
}
|
|
void disableRotation() {
|
|
rotate_allowed = false;
|
|
}
|
|
|
|
void turnIntoShadow() {
|
|
for(auto &block : getObjects() ) {
|
|
block->setId(SHADOW_ID);
|
|
block->setColor("#AAAAAAAA");
|
|
}
|
|
}
|
|
std::shared_ptr<TetrisPiece> copySelf() {
|
|
auto ret = std::make_shared<TetrisPiece>();
|
|
for(int i = 0; i < 4; i++) {
|
|
auto block = pieces[i]->copyInScene();
|
|
block->centerX();
|
|
ret->addBlockInPos(block, pieces_rel_position[i]);
|
|
}
|
|
return ret;
|
|
}
|
|
void destroy() {
|
|
for(auto &x : getObjects()) {
|
|
x->destroy();
|
|
}
|
|
}
|
|
void addMovement(int x, int y) {
|
|
movement.first += x;
|
|
movement.second += y;
|
|
}
|
|
std::pair<int,int> getMovement() const {
|
|
return movement;
|
|
}
|
|
|
|
private:
|
|
bool 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 resetBlock(int index, std::shared_ptr< TetrisBlock > piece) {
|
|
piece->setPos(pieces[index]->getPos());
|
|
pieces[index] = piece;
|
|
}
|
|
void addBlockInPos(std::shared_ptr<TetrisBlock> piece, const std::vector<int> &relpos) {
|
|
pieces.push_back( piece );
|
|
pieces_rel_position.push_back(relpos);
|
|
}
|
|
std::vector< std::vector< int > > pieces_rel_position;
|
|
std::vector< std::shared_ptr< TetrisBlock > > pieces;
|
|
std::vector< std::pair< double, double > > original_pos;
|
|
bool descend = false;
|
|
int userMovement = 0;
|
|
bool rotate_allowed = true;
|
|
std::pair<int,int> movement = {0,0};
|
|
};
|
|
|
|
std::vector< std::shared_ptr< SDLPP::RectangleRender > > line_coliders;
|
|
std::shared_ptr< TetrisPiece > cur_object;
|
|
std::shared_ptr< TetrisPiece > next_object;
|
|
std::shared_ptr< TetrisPiece > cur_shadow;
|
|
std::shared_ptr< SDLPP::RectangleRender > shadow_colider;
|
|
|
|
void doInput( std::shared_ptr< SDLPP::Scene > scene );
|
|
void doInputPause();
|
|
void doInputGameOver();
|
|
bool quit = false;
|
|
|
|
std::mutex movement_mutex;
|
|
|
|
std::shared_ptr< TetrisPiece >
|
|
tetrisBrick( std::shared_ptr< SDLPP::Renderer > renderer,
|
|
std::shared_ptr< SDLPP::Scene > scene ) {
|
|
auto retPiece = std::make_shared< TetrisPiece >();
|
|
auto color = "#FF0000";
|
|
auto outline = "#AA0000";
|
|
retPiece->addPiece( createTetrisBlock( 0.5 - BLOCK_SIZE, TOP_BORDER, color,
|
|
outline, TETRIS_BRICK, renderer,
|
|
scene ),
|
|
-1, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5, TOP_BORDER, color, outline,
|
|
TETRIS_BRICK, renderer, scene ),
|
|
0, 0 );
|
|
retPiece->addPiece(
|
|
createTetrisBlock( 0.5 - BLOCK_SIZE, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_BRICK, renderer, scene ),
|
|
-1, 1 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_BRICK, renderer,
|
|
scene ),
|
|
0, 1 );
|
|
retPiece->disableRotation();
|
|
return retPiece;
|
|
}
|
|
|
|
std::shared_ptr< TetrisPiece >
|
|
tetrisT( std::shared_ptr< SDLPP::Renderer > renderer,
|
|
std::shared_ptr< SDLPP::Scene > scene ) {
|
|
auto retPiece = std::make_shared< TetrisPiece >();
|
|
auto color = "#00FF00";
|
|
auto outline = "#00AA00";
|
|
retPiece->addPiece( createTetrisBlock( 0.5 - BLOCK_SIZE,
|
|
TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_T, renderer, scene ),
|
|
-1, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_T, renderer, scene ),
|
|
0, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5, TOP_BORDER, color, outline,
|
|
TETRIS_T, renderer, scene ),
|
|
0, -1 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5 + BLOCK_SIZE,
|
|
TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_T, renderer, scene ),
|
|
1, 0 );
|
|
return retPiece;
|
|
}
|
|
|
|
std::shared_ptr< TetrisPiece >
|
|
tetrisLRight( std::shared_ptr< SDLPP::Renderer > renderer,
|
|
std::shared_ptr< SDLPP::Scene > scene ) {
|
|
auto retPiece = std::make_shared< TetrisPiece >();
|
|
auto color = "#0000FF";
|
|
auto outline = "#0000AA";
|
|
retPiece->addPiece(
|
|
createTetrisBlock( 0.5 - BLOCK_SIZE, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_L_RIGHT, renderer, scene ),
|
|
-2, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_L_RIGHT, renderer,
|
|
scene ),
|
|
-1, 0 );
|
|
retPiece->addPiece(
|
|
createTetrisBlock( 0.5 + BLOCK_SIZE, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_L_RIGHT, renderer, scene ),
|
|
0, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5 + BLOCK_SIZE, TOP_BORDER, color,
|
|
outline, TETRIS_L_RIGHT, renderer,
|
|
scene ),
|
|
0, -1 );
|
|
return retPiece;
|
|
}
|
|
|
|
std::shared_ptr< TetrisPiece >
|
|
tetrisZRight( std::shared_ptr< SDLPP::Renderer > renderer,
|
|
std::shared_ptr< SDLPP::Scene > scene ) {
|
|
auto retPiece = std::make_shared< TetrisPiece >();
|
|
auto color = "#FF00FF";
|
|
auto outline = "#AA00AA";
|
|
retPiece->addPiece(
|
|
createTetrisBlock( 0.5 - BLOCK_SIZE, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_Z_RIGHT, renderer, scene ),
|
|
-1, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_Z_RIGHT, renderer,
|
|
scene ),
|
|
0, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5, TOP_BORDER, color, outline,
|
|
TETRIS_Z_RIGHT, renderer, scene ),
|
|
0, -1 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5 + BLOCK_SIZE, TOP_BORDER, color,
|
|
outline, TETRIS_Z_RIGHT, renderer,
|
|
scene ),
|
|
1, -1 );
|
|
return retPiece;
|
|
}
|
|
|
|
std::shared_ptr< TetrisPiece >
|
|
tetrisLine( std::shared_ptr< SDLPP::Renderer > renderer,
|
|
std::shared_ptr< SDLPP::Scene > scene ) {
|
|
auto retPiece = std::make_shared< TetrisPiece >();
|
|
auto color = "#FFFF00";
|
|
auto outline = "#AAAA00";
|
|
retPiece->addPiece( createTetrisBlock( 0.5 - 2 * BLOCK_SIZE, TOP_BORDER,
|
|
color, outline, TETRIS_LINE,
|
|
renderer, scene ),
|
|
-1, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5 - BLOCK_SIZE, TOP_BORDER, color,
|
|
outline, TETRIS_LINE, renderer,
|
|
scene ),
|
|
0, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5, TOP_BORDER, color, outline,
|
|
TETRIS_LINE, renderer, scene ),
|
|
1, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5 + BLOCK_SIZE, TOP_BORDER, color,
|
|
outline, TETRIS_LINE, renderer,
|
|
scene ),
|
|
2, 0 );
|
|
return retPiece;
|
|
}
|
|
|
|
std::shared_ptr< TetrisPiece >
|
|
tetrisLLeft( std::shared_ptr< SDLPP::Renderer > renderer,
|
|
std::shared_ptr< SDLPP::Scene > scene ) {
|
|
auto retPiece = std::make_shared< TetrisPiece >();
|
|
auto color = "#00FFFF";
|
|
auto outline = "#00AAAA";
|
|
retPiece->addPiece( createTetrisBlock( 0.5 - BLOCK_SIZE, TOP_BORDER, color,
|
|
outline, TETRIS_L_LEFT, renderer,
|
|
scene ),
|
|
0, -1 );
|
|
retPiece->addPiece(
|
|
createTetrisBlock( 0.5 - BLOCK_SIZE, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_L_LEFT, renderer, scene ),
|
|
0, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_L_LEFT, renderer,
|
|
scene ),
|
|
1, 0 );
|
|
retPiece->addPiece(
|
|
createTetrisBlock( 0.5 + BLOCK_SIZE, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_L_LEFT, renderer, scene ),
|
|
2, 0 );
|
|
return retPiece;
|
|
}
|
|
|
|
std::shared_ptr< TetrisPiece >
|
|
tetrisZLeft( std::shared_ptr< SDLPP::Renderer > renderer,
|
|
std::shared_ptr< SDLPP::Scene > scene ) {
|
|
auto retPiece = std::make_shared< TetrisPiece >();
|
|
auto color = "#FFFFFF";
|
|
auto outline = "#AAAAAA";
|
|
retPiece->addPiece( createTetrisBlock( 0.5 - BLOCK_SIZE, TOP_BORDER, color,
|
|
outline, TETRIS_Z_LEFT, renderer,
|
|
scene ),
|
|
-1, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5, TOP_BORDER, color, outline,
|
|
TETRIS_Z_LEFT, renderer, scene ),
|
|
0, 0 );
|
|
retPiece->addPiece( createTetrisBlock( 0.5, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_Z_LEFT, renderer,
|
|
scene ),
|
|
0, 1 );
|
|
retPiece->addPiece(
|
|
createTetrisBlock( 0.5 + BLOCK_SIZE, TOP_BORDER + BLOCK_SIZE, color,
|
|
outline, TETRIS_Z_LEFT, renderer, scene ),
|
|
1, 1 );
|
|
return retPiece;
|
|
}
|
|
|
|
std::vector< std::shared_ptr< 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< SDLPP::Renderer > &r ) {
|
|
auto bg = std::make_shared< SDLPP::RectangleRender >( 0, 0, 10, 10, r,
|
|
"#222222", true );
|
|
bg->setPermanent();
|
|
scene.addObject( bg );
|
|
|
|
double posy = 1;
|
|
for ( int i = 0; i < 20; i++ ) {
|
|
posy -= BLOCK_SIZE;
|
|
auto colider = std::make_shared< SDLPP::RectangleRender >(
|
|
LEFT_BORDER, posy, RIGHT_BORDER - LEFT_BORDER, BLOCK_SIZE, r );
|
|
colider->addCollision(SDLPP::Rect( 0.01, 0.1, 0.98, 0.8 ));
|
|
colider->setId( COLIDER_ID );
|
|
colider->setStatic();
|
|
colider->centerX();
|
|
line_coliders.push_back( colider );
|
|
scene.addObject( colider );
|
|
}
|
|
|
|
posy = 1;
|
|
for ( int i = 0; i < 20; i++ ) {
|
|
posy -= BLOCK_SIZE;
|
|
auto line = std::make_shared< SDLPP::LineRenderer >( LEFT_BORDER, posy, RIGHT_BORDER, posy, r, "#AAAAAA" );
|
|
line->setStatic();
|
|
line->centerX();
|
|
scene.addObject( line );
|
|
}
|
|
|
|
auto posx = RIGHT_BORDER;
|
|
for ( int i = 0; i < 9; i++ ) {
|
|
posx -= BLOCK_SIZE;
|
|
auto line = std::make_shared< SDLPP::LineRenderer >( posx, TOP_BORDER + BLOCK_SIZE, posx, BOTTOM_BORDER, r, "#AAAAAA" );
|
|
line->setStatic();
|
|
line->centerX();
|
|
scene.addObject( line );
|
|
}
|
|
|
|
auto left_barrier = std::make_shared< SDLPP::RectangleRender >(
|
|
LEFT_BORDER - 0.02, 0, 0.02, BOTTOM_BORDER, r, "#AA0000", true );
|
|
left_barrier->centerX();
|
|
left_barrier->setStatic();
|
|
scene.addObject( left_barrier );
|
|
auto right_barrier = std::make_shared< SDLPP::RectangleRender >(
|
|
RIGHT_BORDER, 0, 0.02, BOTTOM_BORDER, r, "#AA0000", true );
|
|
right_barrier->centerX();
|
|
right_barrier->setStatic();
|
|
scene.addObject( right_barrier );
|
|
auto bottom_barrier = std::make_shared< SDLPP::RectangleRender >(
|
|
LEFT_BORDER - 0.02, BOTTOM_BORDER, RIGHT_BORDER - LEFT_BORDER + 0.04,
|
|
0.02, r, "#AA0000", true );
|
|
bottom_barrier->centerX();
|
|
bottom_barrier->setStatic();
|
|
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();
|
|
tetris->setStatic();
|
|
scene.addObject( tetris );
|
|
auto next = std::make_shared< SDLPP::TextRenderer >(
|
|
RIGHT_BORDER + 0.1, 0.35, 0.2, 0.1, r, *font, "NEXT", "FFFFFF",
|
|
"000000", 5, SDLPP_TEXT_CENTER );
|
|
next->centerX();
|
|
next->setStatic();
|
|
scene.addObject( next );
|
|
auto gameover = std::make_shared< SDLPP::RectangleRender >(
|
|
0.5, 0, 0, TOP_BORDER + BLOCK_SIZE, r );
|
|
auto gameover_collision = SDLPP::Rect( -1, 0, -1, 0.9 );
|
|
gameover_collision.setInfinite();
|
|
gameover->addCollision( gameover_collision );
|
|
gameover->setId( GAME_OVER );
|
|
gameover->setColiderColor( "FF0000" );
|
|
gameover->setStatic();
|
|
scene.addObject( gameover );
|
|
auto score_text = std::make_shared< SDLPP::TextRenderer >(
|
|
RIGHT_BORDER + 0.1, 0.1, 0.2, 0.1, r, *font, "SCORE", "#FFFFFF",
|
|
"#000000", 5, SDLPP_TEXT_CENTER );
|
|
score_text->centerX();
|
|
score_text->setStatic();
|
|
scene.addObject( score_text );
|
|
|
|
score_texture = std::make_shared< SDLPP::TextRenderer >(
|
|
RIGHT_BORDER + 0.1, 0.2, 0.2, 0.1, r, *font, std::to_string( score ),
|
|
"FFFFFF", "000000", 5, SDLPP_TEXT_TOP );
|
|
score_texture->centerX();
|
|
score_texture->setStatic();
|
|
scene.addObject( score_texture );
|
|
|
|
auto shcol = std::make_shared< SDLPP::RectangleRender >( 0, TOP_BORDER, BLOCK_SIZE, BOTTOM_BORDER - TOP_BORDER, r );
|
|
shcol->addCollision(SDLPP::Rect( 0.1, 0.01, 0.8, 0.98 ));
|
|
shcol->setId( COLIDER_ID );
|
|
shcol->setStatic();
|
|
shcol->centerX();
|
|
shadow_colider = shcol;
|
|
scene.addObject( shadow_colider );
|
|
|
|
auto border = std::make_shared< SDLPP::RectangleRender >( LEFT_BORDER - 1, TOP_BORDER, 1, BOTTOM_BORDER, r);
|
|
border->setId( BORDER_LEFT_ID );
|
|
border->setStatic();
|
|
border->centerX();
|
|
border->addCollision(SDLPP::Rect( 0, 0, 0.99, 1));
|
|
border->setColiderColor("#FF00FF");
|
|
scene.addObject(border);
|
|
|
|
border = std::make_shared< SDLPP::RectangleRender >( RIGHT_BORDER, TOP_BORDER, 1, BOTTOM_BORDER, r);
|
|
border->setId( BORDER_RIGHT_ID );
|
|
border->setStatic();
|
|
border->centerX();
|
|
border->addCollision(SDLPP::Rect( 0.01, 0, 1, 1));
|
|
border->setColiderColor("#FF00FF");
|
|
scene.addObject(border);
|
|
|
|
auto floor = std::make_shared< SDLPP::RectangleRender >( LEFT_BORDER, BOTTOM_BORDER, RIGHT_BORDER - LEFT_BORDER, 1, r);
|
|
floor->setId( FLOOR_ID );
|
|
floor->setStatic();
|
|
floor->centerX();
|
|
floor->addCollision(SDLPP::Rect(0, 0.01, 1, 1));
|
|
floor->setColiderColor("#00FF00");
|
|
scene.addObject(floor);
|
|
}
|
|
|
|
void updateScore() {
|
|
score_texture->setText( *font, std::to_string( score ), "#FFFFFF",
|
|
"#000000", 5 );
|
|
}
|
|
|
|
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< SDLPP::TextRenderer >( 0.4, 0.51, 0.2, 0.08, r );
|
|
resume->setText( *font, "Resume", "#FFFFFF", "#000000", 5 );
|
|
resume->setColor( "#FFFFFF40" );
|
|
resume->centerX();
|
|
scene.addObject( resume );
|
|
pause_options.push_back( resume );
|
|
auto restart =
|
|
std::make_shared< SDLPP::TextRenderer >( 0.4, 0.61, 0.2, 0.08, r );
|
|
restart->setText( *font, "Restart", "#FFFFFF", "#000000", 5 );
|
|
restart->centerX();
|
|
scene.addObject( restart );
|
|
pause_options.push_back( restart );
|
|
auto quit =
|
|
std::make_shared< SDLPP::TextRenderer >( 0.4, 0.71, 0.2, 0.08, r );
|
|
quit->setText( *font, "Quit Game", "#FFFFFF", "#000000", 5 );
|
|
quit->centerX();
|
|
scene.addObject( quit );
|
|
pause_options.push_back( quit );
|
|
}
|
|
|
|
void addGameOver( 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, "GAME OVER", "#FFFFFF", "#000000", 5 );
|
|
y->setId( 0 );
|
|
y->centerX();
|
|
scene.addObject( y );
|
|
auto restart =
|
|
std::make_shared< SDLPP::TextRenderer >( 0.4, 0.5, 0.2, 0.1, r );
|
|
restart->setText( *font, "Restart", "#FFFFFF", "#000000", 5 );
|
|
restart->centerX();
|
|
restart->setColor( "#FFFFFF40" );
|
|
scene.addObject( restart );
|
|
game_over_options.push_back( restart );
|
|
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 );
|
|
game_over_options.push_back( quit );
|
|
}
|
|
|
|
void quitGame() {
|
|
std::cout << "Quitting!" << std::endl;
|
|
quit = true;
|
|
}
|
|
|
|
int crashFlags( std::shared_ptr<TetrisPiece> piece, std::shared_ptr<TetrisBlock> block, SDLPP::Scene &scene, int left, int right, int bottom) {
|
|
int retFlags = 0;
|
|
auto collisions = scene.getCollisions(*block, {BORDER_LEFT_ID, BORDER_RIGHT_ID, FLOOR_ID});
|
|
for(auto &col : collisions) {
|
|
switch(col->getId()) {
|
|
case BORDER_LEFT_ID:
|
|
retFlags |= left;
|
|
break;
|
|
case BORDER_RIGHT_ID:
|
|
retFlags |= right;
|
|
break;
|
|
case FLOOR_ID:
|
|
retFlags |= right;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
collisions = scene.getCollisions(*block, {BRICK_ID});
|
|
if(collisions.size() > 1) {
|
|
for(auto &col : collisions) {
|
|
if(piece->isLeft(*col))
|
|
retFlags |= left;
|
|
else if(piece->isRight(*col))
|
|
retFlags |= right;
|
|
else
|
|
retFlags |= bottom;
|
|
}
|
|
}
|
|
return retFlags;
|
|
}
|
|
|
|
bool checkRotation( std::shared_ptr<TetrisPiece> piece, SDLPP::Scene &scene ) {
|
|
int crash = 0;
|
|
int cur_left = 0x01;
|
|
int cur_right = 0x02;
|
|
int was_left = 0x04;
|
|
int was_right = 0x08;
|
|
int bottom = 0x10;
|
|
do {
|
|
crash = 0;
|
|
for(auto &block : piece->getObjects()) {
|
|
crash |= crashFlags(piece, block, scene, cur_left, cur_right, bottom);
|
|
}
|
|
if(crash & bottom || (crash & cur_left && crash & cur_right) ||
|
|
(crash & cur_left && crash & was_right) || (crash & cur_right && crash & was_left)) {
|
|
piece->revert();
|
|
return false;
|
|
}
|
|
crash &= ~(was_left | was_right);
|
|
if(crash & cur_left) {
|
|
piece->movePiece(BLOCK_SIZE, 0);
|
|
crash &= ~cur_left;
|
|
crash |= was_left;
|
|
}
|
|
if(crash & cur_right) {
|
|
piece->movePiece(-BLOCK_SIZE, 0);
|
|
crash &= ~cur_right;
|
|
crash |= was_right;
|
|
}
|
|
} while(crash);
|
|
return true;
|
|
}
|
|
|
|
void updateShadow(SDLPP::Scene &scene) {
|
|
if(!cur_object) {
|
|
cur_shadow->destroy();
|
|
cur_shadow.reset();
|
|
return;
|
|
}
|
|
cur_shadow->setPos(cur_object->getPos());
|
|
double shadow_drop = BOTTOM_BORDER;
|
|
auto &invalid_objects = cur_object->getObjects();
|
|
for( auto &x : cur_shadow->getObjects() ) {
|
|
if(BOTTOM_BORDER - x->getPos().second < shadow_drop)
|
|
shadow_drop = BOTTOM_BORDER - x->getPos().second;
|
|
shadow_colider->setPos(x->getPos().first, TOP_BORDER);
|
|
auto collisions = scene.getCollisions( *shadow_colider, { BRICK_ID } );
|
|
auto curY = x->getPos().second;
|
|
for(auto &col : collisions) {
|
|
auto colY = col->getPos().second;
|
|
if(std::find(invalid_objects.begin(), invalid_objects.end(), col) != invalid_objects.end())
|
|
continue;
|
|
auto possible_drop = colY - curY;
|
|
if(possible_drop < shadow_drop && possible_drop >= 0)
|
|
shadow_drop = colY - curY;
|
|
}
|
|
}
|
|
shadow_drop -= BLOCK_SIZE;
|
|
cur_shadow->setPos(cur_shadow->getPos().first, cur_shadow->getPos().second + shadow_drop);
|
|
}
|
|
|
|
bool validPos(SDLPP::Scene &scene, std::shared_ptr<TetrisPiece> piece) {
|
|
auto ret = true;
|
|
for ( auto &x : piece->getObjects() ) {
|
|
auto collisions = scene.getCollisions( *x, { BRICK_ID, FLOOR_ID, BORDER_LEFT_ID, BORDER_RIGHT_ID } );
|
|
if ( collisions.size() > 1 ) {
|
|
ret = false;
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void handleKeyDown( SDL_Keycode key, SDLPP::Scene &scene ) {
|
|
switch ( key ) {
|
|
case SDLK_ESCAPE:
|
|
{
|
|
pause = PAUSE_PAUSE;
|
|
pause_scene->updateSizeAndPosition();
|
|
std::thread pauseThread( doInputPause );
|
|
pauseThread.detach();
|
|
} break;
|
|
case SDLK_LEFT:
|
|
case SDLK_a:
|
|
if(!cur_object)
|
|
break;
|
|
cur_object->movePiece(-BLOCK_SIZE, 0);
|
|
if(!validPos(scene, cur_object))
|
|
cur_object->movePiece(BLOCK_SIZE, 0);
|
|
updateShadow(scene);
|
|
|
|
ticks_till_movement = 2*TICKS_TILL_MOVE;
|
|
cur_object->startMovement();
|
|
cur_object->addMovement(-1,0);
|
|
break;
|
|
case SDLK_RIGHT:
|
|
case SDLK_d:
|
|
if(!cur_object)
|
|
break;
|
|
cur_object->movePiece(BLOCK_SIZE, 0);
|
|
if(!validPos(scene, cur_object))
|
|
cur_object->movePiece(-BLOCK_SIZE, 0);
|
|
updateShadow(scene);
|
|
|
|
ticks_till_movement = 2*TICKS_TILL_MOVE;
|
|
cur_object->startMovement();
|
|
cur_object->addMovement(1,0);
|
|
break;
|
|
case SDLK_DOWN:
|
|
case SDLK_s:
|
|
if(!cur_object)
|
|
break;
|
|
cur_object->startDescend();
|
|
cur_object->addMovement(0,1);
|
|
break;
|
|
case SDLK_UP:
|
|
case SDLK_w:
|
|
if(!cur_object)
|
|
break;
|
|
cur_object->rotate();
|
|
if( checkRotation( cur_object, scene ) )
|
|
cur_shadow->rotate();
|
|
updateShadow(scene);
|
|
break;
|
|
case SDLK_r:
|
|
scene.getRenderer().setRenderColiders(
|
|
!scene.getRenderer().getRenderColiders() );
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void handleKeyUp( SDL_Keycode key ) {
|
|
switch(key) {
|
|
case SDLK_DOWN:
|
|
case SDLK_s:
|
|
if(!cur_object)
|
|
break;
|
|
if(cur_object->isDescending()) {
|
|
cur_object->stopDescend();
|
|
cur_object->addMovement(0,-1);
|
|
ticks_till_descend = TICKS_TILL_DESCEND;
|
|
}
|
|
break;
|
|
case SDLK_LEFT:
|
|
case SDLK_a:
|
|
if(!cur_object)
|
|
break;
|
|
if(cur_object->isMoving()) {
|
|
cur_object->stopMovement();
|
|
cur_object->addMovement(1,0);
|
|
if(cur_object->isMoving())
|
|
ticks_till_movement = TICKS_TILL_MOVE;
|
|
}
|
|
break;
|
|
case SDLK_RIGHT:
|
|
case SDLK_d:
|
|
if(!cur_object)
|
|
break;
|
|
if(cur_object->isMoving()) {
|
|
cur_object->stopDescend();
|
|
cur_object->addMovement(-1,0);
|
|
if(cur_object->isMoving())
|
|
ticks_till_movement = TICKS_TILL_MOVE;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void handleKeyDownPause( SDL_Keycode key ) {
|
|
switch ( key ) {
|
|
case SDLK_ESCAPE: {
|
|
pause = 0;
|
|
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 = 0;
|
|
active_scene->setPrevTicks( SDL_GetTicks() );
|
|
std::thread inputThread( doInput, active_scene );
|
|
inputThread.detach();
|
|
} break;
|
|
case 1:
|
|
{
|
|
pause = 0;
|
|
cur_object.reset();
|
|
checked_line = true;
|
|
next_object.reset();
|
|
score = 0;
|
|
update_score = true;
|
|
active_scene->resetScene();
|
|
active_scene->setPrevTicks( SDL_GetTicks() );
|
|
|
|
next_object = tetrisFunctions[std::rand() / ( ( RAND_MAX + 1u ) / 7 )](
|
|
active_scene->getRendererShared(), active_scene );
|
|
next_object->setPos( 0.9, 0.5 );
|
|
std::thread inputThread( doInput, active_scene );
|
|
inputThread.detach();
|
|
}
|
|
break;
|
|
case 2:
|
|
quitGame();
|
|
default:
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void handleKeyDownGameOver( SDL_Keycode key ) {
|
|
switch ( key ) {
|
|
case SDLK_r:
|
|
active_scene->getRenderer().setRenderColiders(
|
|
!active_scene->getRenderer().getRenderColiders() );
|
|
break;
|
|
case SDLK_s:
|
|
case SDLK_DOWN:
|
|
game_over_options[game_over_select]->unsetColor();
|
|
game_over_select++;
|
|
if ( game_over_select > game_over_max )
|
|
game_over_select = 0;
|
|
game_over_options[game_over_select]->setColor( "FFFFFF40" );
|
|
break;
|
|
case SDLK_w:
|
|
case SDLK_UP:
|
|
game_over_options[game_over_select]->unsetColor();
|
|
game_over_select--;
|
|
if ( game_over_select < 0 )
|
|
game_over_select = game_over_max;
|
|
game_over_options[game_over_select]->setColor( "FFFFFF40" );
|
|
break;
|
|
case SDLK_RETURN:
|
|
switch ( game_over_select ) {
|
|
case 0:
|
|
{
|
|
// TODO reset function
|
|
pause = 0;
|
|
cur_object.reset();
|
|
checked_line = true;
|
|
next_object.reset();
|
|
score = 0;
|
|
update_score = true;
|
|
active_scene->resetScene();
|
|
active_scene->setPrevTicks( SDL_GetTicks() );
|
|
|
|
next_object = tetrisFunctions[std::rand() / ( ( RAND_MAX + 1u ) / 7 )](
|
|
active_scene->getRendererShared(), active_scene );
|
|
next_object->setPos( 0.9, 0.5 );
|
|
std::thread inputThread( doInput, active_scene );
|
|
inputThread.detach();
|
|
}
|
|
break;
|
|
case 1:
|
|
quitGame();
|
|
default:
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
void pollEventsGameOver() {
|
|
SDL_Event event;
|
|
while ( SDL_PollEvent( &event ) != 0 ) {
|
|
switch ( event.type ) {
|
|
case SDL_QUIT:
|
|
quitGame();
|
|
break;
|
|
case SDL_KEYDOWN:
|
|
if ( !event.key.repeat )
|
|
handleKeyDownGameOver( event.key.keysym.sym );
|
|
break;
|
|
case SDL_WINDOWEVENT:
|
|
if ( event.window.event == SDL_WINDOWEVENT_RESIZED ) {
|
|
active_scene->updateSizeAndPosition();
|
|
game_over_scene->updateSizeAndPosition();
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void moveThem( std::shared_ptr< SDLPP::Scene > scene, int ticks ) {
|
|
auto movement = cur_object->getMovement();
|
|
ticks_till_fall -= ticks;
|
|
if ( cur_object->isDescending() )
|
|
ticks_till_descend -= ticks;
|
|
if ( cur_object->isMoving() )
|
|
ticks_till_movement -= ticks;
|
|
if ( ticks_till_fall > 0 ) {
|
|
if ( cur_object->isDescending() && ticks_till_descend <= 0 ) {
|
|
ticks_till_descend = TICKS_TILL_DESCEND;
|
|
cur_object->movePiece(0, movement.second * BLOCK_SIZE);
|
|
if(!validPos(*scene, cur_object)) {
|
|
cur_object->movePiece(0, movement.second * -BLOCK_SIZE);
|
|
return;
|
|
} else
|
|
goto check_floor;
|
|
}
|
|
if ( cur_object->isMoving() && ticks_till_movement <= 0 ) {
|
|
ticks_till_movement = TICKS_TILL_MOVE;
|
|
cur_object->movePiece(movement.first * BLOCK_SIZE, 0);
|
|
if(!validPos(*scene, cur_object)) {
|
|
cur_object->movePiece(movement.first * -BLOCK_SIZE, 0);
|
|
return;
|
|
} else
|
|
goto check_floor;
|
|
}
|
|
return;
|
|
}
|
|
ticks_till_fall = TICKS_TILL_FALL;
|
|
cur_object->movePiece(0, BLOCK_SIZE);
|
|
check_floor:
|
|
bool fell = false;
|
|
for ( auto &x : cur_object->getObjects() ) {
|
|
auto collisions = scene->getCollisions( *x, { BRICK_ID, FLOOR_ID } );
|
|
if ( collisions.size() > 1 ) {
|
|
fell = true;
|
|
break;
|
|
}
|
|
}
|
|
if ( fell ) {
|
|
cur_object->movePiece(0, -BLOCK_SIZE);
|
|
for ( auto &block : cur_object->getObjects() ) {
|
|
if ( scene->getCollisions( *block, { GAME_OVER } ).size() > 0 ) {
|
|
pause = PAUSE_GAME_OVER;
|
|
game_over_scene->updateSizeAndPosition();
|
|
std::thread pauseThread( doInputGameOver );
|
|
pauseThread.detach();
|
|
}
|
|
}
|
|
cur_object.reset();
|
|
}
|
|
updateShadow(*scene);
|
|
}
|
|
|
|
void doInput( std::shared_ptr< SDLPP::Scene > scene ) {
|
|
FPSmanager gFPS;
|
|
SDL_initFramerate( &gFPS );
|
|
SDL_setFramerate( &gFPS, 200 );
|
|
auto base = SDL_GetTicks();
|
|
while ( !quit && !pause ) {
|
|
base = SDL_GetTicks();
|
|
SDL_framerateDelay( &gFPS );
|
|
std::lock_guard< std::mutex > guard( movement_mutex );
|
|
pollEvents( *scene );
|
|
if ( cur_object ) {
|
|
moveThem( scene, SDL_GetTicks() - base );
|
|
continue;
|
|
}
|
|
for ( auto &colider : line_coliders ) {
|
|
auto collisions = scene->getCollisions( *colider, { BRICK_ID } );
|
|
while ( collisions.size() == 10 ) {
|
|
score += 10;
|
|
update_score = true;
|
|
for ( auto &col : collisions ) {
|
|
col->destroy();
|
|
}
|
|
auto colider_y = colider->getPos().second;
|
|
for ( auto &elem : scene->getObjects() ) {
|
|
if ( elem->getId() != BRICK_ID )
|
|
continue;
|
|
auto pos = elem->getPos();
|
|
if ( pos.second < colider_y && pos.first >= LEFT_BORDER && pos.first <= RIGHT_BORDER ) {
|
|
elem->setPos( pos.first, pos.second + BLOCK_SIZE );
|
|
}
|
|
}
|
|
using namespace std::chrono_literals;
|
|
wait_for_anim = true;
|
|
while ( wait_for_anim ) {
|
|
std::this_thread::sleep_for( 0.1s );
|
|
}
|
|
collisions = scene->getCollisions( *colider, { BRICK_ID } );
|
|
}
|
|
}
|
|
checked_line = true;
|
|
}
|
|
}
|
|
|
|
void doInputPause() {
|
|
FPSmanager gFPS;
|
|
SDL_initFramerate( &gFPS );
|
|
SDL_setFramerate( &gFPS, 200 );
|
|
while ( pause ) {
|
|
SDL_framerateDelay( &gFPS );
|
|
pollEventsPause();
|
|
if ( !pause )
|
|
break;
|
|
}
|
|
}
|
|
|
|
void doInputGameOver() {
|
|
FPSmanager gFPS;
|
|
SDL_initFramerate( &gFPS );
|
|
SDL_setFramerate( &gFPS, 200 );
|
|
while ( pause ) {
|
|
SDL_framerateDelay( &gFPS );
|
|
pollEventsGameOver();
|
|
if ( !pause )
|
|
break;
|
|
}
|
|
}
|
|
|
|
int main() {
|
|
SDLPP::init();
|
|
SDLPP::Window w( "Tetris clone!" );
|
|
w.setResizable(true);
|
|
auto renderer = std::make_shared< SDLPP::Renderer >( w );
|
|
active_renderer = renderer;
|
|
renderer->setBlendMode( SDL_BLENDMODE_BLEND );
|
|
auto main_scene = std::make_shared< SDLPP::Scene >( renderer );
|
|
active_scene = main_scene;
|
|
font = std::make_shared< SDLPP::Font >( "testfont.ttf", 96 );
|
|
addStuff( *main_scene, renderer );
|
|
main_scene->saveScene();
|
|
|
|
pause_scene = std::make_shared< SDLPP::Scene >( renderer );
|
|
addPause( *pause_scene, renderer );
|
|
game_over_scene = std::make_shared<SDLPP::Scene>(renderer);
|
|
addGameOver(*game_over_scene, renderer);
|
|
|
|
auto base = SDL_GetTicks();
|
|
int frames = 0;
|
|
|
|
std::srand( std::time( nullptr ) );
|
|
FPSmanager gFPS;
|
|
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 && checked_line ) {
|
|
std::lock_guard< std::mutex > guard( movement_mutex );
|
|
cur_object = next_object;
|
|
cur_object->setPos( 0.5, TOP_BORDER - BLOCK_SIZE );
|
|
cur_shadow = cur_object->copySelf();
|
|
cur_shadow->turnIntoShadow();
|
|
for(auto &piece : cur_shadow->getObjects()) {
|
|
active_scene->moveZ(piece, -4);
|
|
}
|
|
updateShadow(*main_scene);
|
|
auto rand_index = std::rand() / ( ( RAND_MAX + 1u ) / 7 );
|
|
int retries = 0;
|
|
while ( bag[rand_index] < 4 ) {
|
|
rand_index = ( rand_index + 1 ) % 7;
|
|
retries++;
|
|
if ( retries == 7 )
|
|
quitGame();
|
|
}
|
|
next_object.reset();
|
|
next_object = tetrisFunctions[rand_index]( renderer, main_scene );
|
|
next_object->setPos( 0.9, 0.5 );
|
|
checked_line = false;
|
|
}
|
|
if ( update_score ) {
|
|
updateScore();
|
|
update_score = false;
|
|
}
|
|
|
|
main_scene->renderScene();
|
|
if ( pause == PAUSE_PAUSE ) {
|
|
pause_scene->renderScene( false );
|
|
} else if ( pause == PAUSE_GAME_OVER ) {
|
|
game_over_scene->renderScene( false );
|
|
}
|
|
main_scene->presentScene();
|
|
wait_for_anim = false;
|
|
frames++;
|
|
if ( SDL_GetTicks() - base >= 1000 ) {
|
|
base = SDL_GetTicks();
|
|
std::cout << "FPS: " << frames << std::endl;
|
|
frames = 0;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|