zv0n/game
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

TETRIS: use new sdlpp library

Browse Source
This commit is contained in:
zvon 2020-11-21 20:58:52 +01:00
parent a67e9e5b1a
commit 90879a3f21
11 changed files with 635 additions and 507 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
tetris/Makefile
View File

@ -6,14 +6,12 @@ LDFLAGS ?= -lSDL2 -lSDL2_image -lSDL2_gfx -lSDL2_ttf -pthread
.PHONY: default
default: tetris
tetris: tetris.o sdlpp.o scenes.o config.o functions.o global_vars.o
$(CXX) $(CFLAGS) -o $@ $^ ${LDFLAGS}
tetris: tetris.o scenes.o config.o functions.o global_vars.o libsdlpp.so
$(CXX) $(CFLAGS) -o $@ $^ ${LDFLAGS} -L -llibsdlpp
sdlpp.o: ../sdlpp.cpp ../sdlpp.hpp
tetris.o: tetris.cpp ../sdlpp/sdlpp.hpp config.hpp custom_classes.hpp scenes.hpp global_vars.hpp functions.hpp
$(CXX) $(CFLAGS) -c -o $@ $<
tetris.o: tetris.cpp ../sdlpp.hpp config.hpp custom_classes.hpp scenes.hpp global_vars.hpp functions.hpp
$(CXX) $(CFLAGS) -c -o $@ $<
scenes.o: scenes.cpp ../sdlpp.hpp config.hpp scenes.hpp functions.hpp global_vars.hpp
scenes.o: scenes.cpp ../sdlpp/sdlpp.hpp config.hpp scenes.hpp functions.hpp global_vars.hpp
$(CXX) $(CFLAGS) -c -o $@ $<
config.o: config.cpp config.hpp
$(CXX) $(CFLAGS) -c -o $@ $<
@ -21,6 +19,13 @@ functions.o: functions.cpp config.hpp functions.hpp global_vars.hpp scenes.hpp
$(CXX) $(CFLAGS) -c -o $@ $<
global_vars.o: global_vars.cpp config.hpp global_vars.hpp functions.hpp
$(CXX) $(CFLAGS) -c -o $@ $<
libsdlpp.so: ../sdlpp
$(MAKE) -C ../sdlpp
cp ../sdlpp/libsdlpp.so .
ln -sf libsdlpp.so libsdlpp.so.1
start:
LD_LIBRARY_PATH=$$(pwd) ./tetris
clean:
rm -Rf *.o tetris

16
tetris/config.cpp
View File

@ -1,7 +1,8 @@
#include "config.hpp"
std::map< std::string, std::map< std::string, std::string > > color_schemes = {
{ "default", {
{ "default",
{
{ "piece_brick", "#FF0000" },
{ "piece_brick_out", "#AA0000" },
{ "piece_T", "#00FF00" },
@ -26,7 +27,8 @@ std::map<std::string, std::map<std::string, std::string>> color_schemes = {
{ "menu_background", "#000000BB" },
{ "menu_item_background", "#FFFFFF40" },
} },
{ "gruvbox_dark", {
{ "gruvbox_dark",
{
{ "piece_brick", "#cc241d" },
{ "piece_brick_out", "#fb4934" },
{ "piece_T", "#98971a" },
@ -51,7 +53,8 @@ std::map<std::string, std::map<std::string, std::string>> color_schemes = {
{ "menu_background", "#282828BB" },
{ "menu_item_background", "#d5c4a180" },
} },
{ "gruvbox_light", {
{ "gruvbox_light",
{
{ "piece_brick", "#cc241d" },
{ "piece_brick_out", "#9d0006" },
{ "piece_T", "#98971a" },
@ -76,7 +79,8 @@ std::map<std::string, std::map<std::string, std::string>> color_schemes = {
{ "menu_background", "#d5c4a1BB" },
{ "menu_item_background", "#50494580" },
} },
{ "blackandwhite", {
{ "blackandwhite",
{
{ "piece_brick", "#FFFFFF" },
{ "piece_brick_out", "#000000" },
{ "piece_T", "#FFFFFF" },
@ -102,7 +106,9 @@ std::map<std::string, std::map<std::string, std::string>> color_schemes = {
{ "menu_item_background", "#FFFFFF40" },
} },
};
std::vector<std::string> color_schemes_names = { "default", "gruvbox_dark", "gruvbox_light", "blackandwhite" };
std::vector< std::string > color_schemes_names = { "default", "gruvbox_dark",
"gruvbox_light",
"blackandwhite" };
long unsigned int selected_color_scheme = 0;
bool g_show_shadow = true;
bool g_show_3d = false;

3
tetris/config.hpp
View File

@ -55,7 +55,8 @@
#define colors color_schemes[color_schemes_names[selected_color_scheme]]
extern std::map<std::string, std::map<std::string, std::string>> color_schemes;
extern std::map< std::string, std::map< std::string, std::string > >
color_schemes;
extern std::vector< std::string > color_schemes_names;
extern long unsigned int selected_color_scheme;
extern bool g_show_shadow;

24
tetris/custom_classes.hpp
View File

@ -1,7 +1,7 @@
#ifndef TETRIS_CUSTOM_CLASSES_H
#define TETRIS_CUSTOM_CLASSES_H
#include "../sdlpp.hpp"
#include "../sdlpp/sdlpp.hpp"
#include "config.hpp"
class TetrisBlock : public SDLPP::RectangleRender {
@ -9,9 +9,11 @@ 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, std::vector<int> &bag )
: RectangleRender( x, y, w, h, r, img_or_color, is_polygon ), pieces_bag(bag) {
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;
@ -19,7 +21,13 @@ public:
if ( g_show_3d )
setTexture( "block.png" );
}
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, other.pieces_bag) {}
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, other.pieces_bag ) {}
~TetrisBlock() {
if ( _index != PIECE_SHADOW )
pieces_bag[_index]++;
@ -101,8 +109,7 @@ public:
TetrisPiece() {
original_pos.reserve( 4 );
}
void addPiece( std::shared_ptr< TetrisBlock > piece, int x,
int y ) {
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
@ -271,7 +278,8 @@ private:
piece->setPos( pieces[index]->getPos() );
pieces[index] = piece;
}
void addBlockInPos(std::shared_ptr<TetrisBlock> piece, const std::vector<int> &relpos) {
void addBlockInPos( std::shared_ptr< TetrisBlock > piece,
const std::vector< int > &relpos ) {
pieces.push_back( piece );
pieces_rel_position.push_back( relpos );
}

45
tetris/functions.cpp
View File

@ -6,7 +6,8 @@
bool validPos( SDLPP::Scene &scene, std::shared_ptr< TetrisPiece > piece ) {
for ( auto &x : piece->getObjects() ) {
auto collisions = scene.getCollisions( *x, { BRICK_ID, FLOOR_ID, BORDER_LEFT_ID, BORDER_RIGHT_ID } );
auto collisions = scene.getCollisions(
*x, { BRICK_ID, FLOOR_ID, BORDER_LEFT_ID, BORDER_RIGHT_ID } );
if ( collisions.size() > 1 )
return false;
}
@ -30,11 +31,13 @@ void updateShadow(SDLPP::Scene &scene) {
shadow_drop = BOTTOM_BORDER - block_pos.second;
// set colider column's position to current block's X position
g_shadow_colider->setPos( block_pos.first, TOP_BORDER );
auto collisions = scene.getCollisions( *g_shadow_colider, { BRICK_ID } );
auto collisions =
scene.getCollisions( *g_shadow_colider, { BRICK_ID } );
auto curY = block_pos.second;
for ( auto &col : collisions ) {
// if collision with g_cur_object, ignore
if(std::find(invalid_objects.begin(), invalid_objects.end(), col) != invalid_objects.end())
if ( std::find( invalid_objects.begin(), invalid_objects.end(),
col ) != invalid_objects.end() )
continue;
auto possible_drop = col->getPos().second - curY;
if ( possible_drop < shadow_drop && possible_drop >= 0 )
@ -126,9 +129,12 @@ void resetGame() {
g_bag[i] = 28;
}
int crashFlags( std::shared_ptr<TetrisPiece> piece, std::shared_ptr<TetrisBlock> block, SDLPP::Scene &scene, int left, int right, int bottom) {
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});
auto collisions = scene.getCollisions(
*block, { BORDER_LEFT_ID, BORDER_RIGHT_ID, FLOOR_ID } );
for ( auto &col : collisions ) {
switch ( col->getId() ) {
case BORDER_LEFT_ID:
@ -157,7 +163,8 @@ int crashFlags( std::shared_ptr<TetrisPiece> piece, std::shared_ptr<TetrisBlock>
return retFlags;
}
bool checkRotation( std::shared_ptr<TetrisPiece> piece, SDLPP::Scene &scene ) {
bool checkRotation( std::shared_ptr< TetrisPiece > piece,
SDLPP::Scene &scene ) {
int crash = 0;
int cur_left = 0x01;
int cur_right = 0x02;
@ -173,10 +180,12 @@ bool checkRotation( std::shared_ptr<TetrisPiece> piece, SDLPP::Scene &scene ) {
}
crash = 0;
for ( auto &block : piece->getObjects() ) {
crash |= crashFlags(piece, block, scene, cur_left, cur_right, bottom);
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)) {
( crash & cur_left && crash & was_right ) ||
( crash & cur_right && crash & was_left ) ) {
piece->revert();
return false;
}
@ -200,10 +209,11 @@ 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, g_bag );
auto ret =
std::make_shared< TetrisBlock >( x, y, BLOCK_SIZE, BLOCK_SIZE, renderer,
color, true, index, scene, g_bag );
ret->setOutlineColor( outline );
ret->addCollision( SDLPP::Rect( 0.1, 0.1, 0.8, 0.8 ) );
ret->addCollision( SDLPP::RectColider( 0.1, 0.1, 0.8, 0.8 ) );
ret->setId( BRICK_ID );
ret->centerX();
scene->addObject( ret );
@ -397,11 +407,14 @@ void updateColors() {
x->setColor( colors["line"] );
}
for ( auto &x : g_main_scene->getObjects( { TEXT_ID } ) ) {
std::dynamic_pointer_cast<SDLPP::TextRenderer>(x)->setTextColor(*g_font, colors["text"], colors["text_out"], 5);
std::dynamic_pointer_cast< SDLPP::TextRenderer >( x )->setTextColor(
*g_font, colors["text"], colors["text_out"], 5 );
}
g_menu_options[g_menu_select]->setColor( colors["menu_item_background"] );
g_game_over_options[g_game_over_select]->setColor(colors["menu_item_background"]);
g_options_options[g_options_select]->setColor(colors["menu_item_background"]);
g_game_over_options[g_game_over_select]->setColor(
colors["menu_item_background"] );
g_options_options[g_options_select]->setColor(
colors["menu_item_background"] );
for ( auto &x : g_menu_scene->getObjects( { MENU_BACKGROUND_ID } ) ) {
x->setColor( colors["menu_background"] );
}
@ -412,7 +425,7 @@ void updateColors() {
x->setColor( colors["menu_background"] );
}
for ( auto &x : g_options_scene->getObjects( { MENU_ITEM_ID } ) ) {
std::dynamic_pointer_cast<SDLPP::TextRenderer>(x)->setTextColor(*g_font, colors["text"], colors["text_out"]);
std::dynamic_pointer_cast< SDLPP::TextRenderer >( x )->setTextColor(
*g_font, colors["text"], colors["text_out"] );
}
}

2
tetris/functions.hpp
View File

@ -1,7 +1,7 @@
#ifndef TETRIS_FUNCTIONS_H
#define TETRIS_FUNCTIONS_H
#include "../sdlpp.hpp"
#include "../sdlpp/sdlpp.hpp"
#include "custom_classes.hpp"
void moveThem( std::shared_ptr< SDLPP::Scene > scene, int ticks );

5
tetris/global_vars.cpp
View File

@ -36,7 +36,10 @@ std::shared_ptr< SDLPP::RectangleRender > g_shadow_colider{};
std::mutex g_movement_mutex{};
bool g_quit = false;
std::vector<std::function<void(std::shared_ptr<SDLPP::Scene>, int, std::vector<std::shared_ptr<SDLPP::RenderObject>>&)>>g_input_functions{};
std::vector< std::function< void(
std::shared_ptr< SDLPP::Scene >, int,
std::vector< std::shared_ptr< SDLPP::RenderObject > > & ) > >
g_input_functions{};
std::vector< std::shared_ptr< SDLPP::Scene > > g_active_scenes{};
std::vector< std::shared_ptr< TetrisPiece > ( * )(

13
tetris/global_vars.hpp
View File

@ -1,7 +1,7 @@
#ifndef TETRIS_GLOBAL_VARS_H
#define TETRIS_GLOBAL_VARS_H
#include "../sdlpp.hpp"
#include "../sdlpp/sdlpp.hpp"
#include "custom_classes.hpp"
#include <functional>
@ -14,8 +14,10 @@ extern int g_menu_select;
extern int g_game_over_select;
extern int g_options_select;
extern std::vector< std::shared_ptr< SDLPP::RectangleRender > > g_menu_options;
extern std::vector< std::shared_ptr< SDLPP::RectangleRender > > g_game_over_options;
extern std::vector< std::shared_ptr< SDLPP::RectangleRender > > g_options_options;
extern std::vector< std::shared_ptr< SDLPP::RectangleRender > >
g_game_over_options;
extern std::vector< std::shared_ptr< SDLPP::RectangleRender > >
g_options_options;
extern std::shared_ptr< SDLPP::TextRenderer > g_score_texture;
extern std::shared_ptr< SDLPP::Renderer > g_active_renderer;
extern int g_score;
@ -40,7 +42,10 @@ extern std::shared_ptr< SDLPP::RectangleRender > g_shadow_colider;
extern std::mutex g_movement_mutex;
extern bool g_quit;
extern std::vector<std::function<void(std::shared_ptr<SDLPP::Scene>, int, std::vector<std::shared_ptr<SDLPP::RenderObject>>&)>>g_input_functions;
extern std::vector< std::function< void(
std::shared_ptr< SDLPP::Scene >, int,
std::vector< std::shared_ptr< SDLPP::RenderObject > > & ) > >
g_input_functions;
extern std::vector< std::shared_ptr< SDLPP::Scene > > g_active_scenes;
extern std::vector< std::shared_ptr< TetrisPiece > ( * )(

178
tetris/scenes.cpp
View File

@ -20,9 +20,11 @@ constexpr uint64_t OPTIONS_MENU_SAVE = 3;
// Scene preparation
void addMainSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer > &r, std::shared_ptr<SDLPP::Font> font ) {
auto bg = std::make_shared< SDLPP::RectangleRender >( 0, 0, 10, 10, r,
colors["background"], true );
void addMainSceneItems( SDLPP::Scene &scene,
std::shared_ptr< SDLPP::Renderer > &r,
std::shared_ptr< SDLPP::Font > font ) {
auto bg = std::make_shared< SDLPP::RectangleRender >(
0, 0, 10, 10, r, colors["background"], true );
bg->setPermanent();
bg->setId( BACKGROUND_ID );
scene.addObject( bg );
@ -33,7 +35,7 @@ void addMainSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer >
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->addCollision( SDLPP::RectColider( 0.01, 0.1, 0.98, 0.8 ) );
colider->setId( COLIDER_ID );
colider->setStatic();
colider->centerX();
@ -44,7 +46,8 @@ void addMainSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer >
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, colors["line"] );
auto line = std::make_shared< SDLPP::LineRenderer >(
LEFT_BORDER, posy, RIGHT_BORDER, posy, r, colors["line"] );
line->setStatic();
line->centerX();
line->setId( LINE_ID );
@ -54,7 +57,9 @@ void addMainSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer >
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, colors["line"] );
auto line = std::make_shared< SDLPP::LineRenderer >(
posx, TOP_BORDER + BLOCK_SIZE, posx, BOTTOM_BORDER, r,
colors["line"] );
line->setStatic();
line->centerX();
line->setId( LINE_ID );
@ -62,7 +67,8 @@ void addMainSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer >
}
auto left_barrier = std::make_shared< SDLPP::RectangleRender >(
LEFT_BORDER - 0.02, 0, 0.02, BOTTOM_BORDER, r, colors["barrier"], true );
LEFT_BORDER - 0.02, 0, 0.02, BOTTOM_BORDER, r, colors["barrier"],
true );
left_barrier->centerX();
left_barrier->setStatic();
left_barrier->setId( BARRIER_ID );
@ -84,14 +90,16 @@ void addMainSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer >
scene.addObject( bottom_barrier );
auto tetris = std::make_shared< SDLPP::TextRenderer >(
0.4, 0, 0.2, 0.1, r, *font, "TETRIS", colors["text"], colors["text_out"], 5 );
0.4, 0, 0.2, 0.1, r, *font, "TETRIS", colors["text"],
colors["text_out"], 5 );
tetris->centerX();
tetris->setStatic();
tetris->setId( TEXT_ID );
scene.addObject( tetris );
auto next = std::make_shared< SDLPP::TextRenderer >(
RIGHT_BORDER + 0.1, 0.35, 0.2, 0.1, r, *font, "NEXT", colors["text"], colors["text_out"], 5, SDLPP_TEXT_CENTER );
RIGHT_BORDER + 0.1, 0.35, 0.2, 0.1, r, *font, "NEXT", colors["text"],
colors["text_out"], 5, SDLPP_TEXT_CENTER );
next->centerX();
next->setStatic();
next->setId( TEXT_ID );
@ -100,7 +108,7 @@ void addMainSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer >
// gameover colider
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 );
auto gameover_collision = SDLPP::RectColider( -1, 0, -1, 0.9 );
gameover_collision.setInfinite();
gameover->addCollision( gameover_collision );
gameover->setId( GAME_OVER );
@ -109,49 +117,54 @@ void addMainSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer >
scene.addObject( gameover );
auto score_text = std::make_shared< SDLPP::TextRenderer >(
RIGHT_BORDER + 0.1, 0.1, 0.2, 0.1, r, *font, "SCORE", colors["text"], colors["text_out"], 5, SDLPP_TEXT_CENTER );
RIGHT_BORDER + 0.1, 0.1, 0.2, 0.1, r, *font, "SCORE", colors["text"],
colors["text_out"], 5, SDLPP_TEXT_CENTER );
score_text->centerX();
score_text->setStatic();
score_text->setId( TEXT_ID );
scene.addObject( score_text );
auto score_texture = std::make_shared< SDLPP::TextRenderer >(
RIGHT_BORDER + 0.1, 0.2, 0.2, 0.1, r, *font, "0",
colors["text"], colors["text_out"], 5, SDLPP_TEXT_TOP );
RIGHT_BORDER + 0.1, 0.2, 0.2, 0.1, r, *font, "0", colors["text"],
colors["text_out"], 5, SDLPP_TEXT_TOP );
score_texture->centerX();
score_texture->setStatic();
score_texture->setId( SCORE_TEXTURE_ID );
scene.addObject( score_texture );
auto border = std::make_shared< SDLPP::RectangleRender >( LEFT_BORDER - 1, 0, 1, BOTTOM_BORDER, r);
auto border = std::make_shared< SDLPP::RectangleRender >(
LEFT_BORDER - 1, 0, 1, BOTTOM_BORDER, r );
border->setId( BORDER_LEFT_ID );
border->setStatic();
border->centerX();
border->addCollision(SDLPP::Rect( 0, 0, 0.99, 1));
border->addCollision( SDLPP::RectColider( 0, 0, 0.99, 1 ) );
border->setColiderColor( "#FF00FF" );
scene.addObject( border );
border = std::make_shared< SDLPP::RectangleRender >( RIGHT_BORDER, 0, 1, BOTTOM_BORDER, r);
border = std::make_shared< SDLPP::RectangleRender >( RIGHT_BORDER, 0, 1,
BOTTOM_BORDER, r );
border->setId( BORDER_RIGHT_ID );
border->setStatic();
border->centerX();
border->addCollision(SDLPP::Rect( 0.01, 0, 1, 1));
border->addCollision( SDLPP::RectColider( 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);
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->addCollision( SDLPP::RectColider( 0, 0.01, 1, 1 ) );
floor->setColiderColor( "#00FF00" );
scene.addObject( floor );
}
void addMenuSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer > &r, std::shared_ptr<SDLPP::Font> font ) {
auto bg = std::make_shared< SDLPP::RectangleRender >( 0, 0, 10, 10, r,
colors["menu_background"], true );
void addMenuSceneItems( SDLPP::Scene &scene,
std::shared_ptr< SDLPP::Renderer > &r,
std::shared_ptr< SDLPP::Font > font ) {
auto bg = std::make_shared< SDLPP::RectangleRender >(
0, 0, 10, 10, r, colors["menu_background"], true );
bg->setId( MENU_BACKGROUND_ID );
bg->setPermanent( true );
scene.addObject( bg );
@ -168,7 +181,8 @@ void addMenuSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer >
resume->setId( MENU_ITEM_ID );
g_menu_options.push_back( resume );
scene.addObject( resume );
auto options = std::make_shared< SDLPP::TextRenderer >(0.4, 0.56, 0.2, 0.08, r);
auto options =
std::make_shared< SDLPP::TextRenderer >( 0.4, 0.56, 0.2, 0.08, r );
options->setText( *font, "Options", colors["text"], colors["text_out"], 5 );
options->centerX();
options->setId( MENU_ITEM_ID );
@ -190,9 +204,11 @@ void addMenuSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer >
scene.addObject( quit );
}
void addGameOverSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer > &r, std::shared_ptr<SDLPP::Font> font ) {
auto bg = std::make_shared< SDLPP::RectangleRender >( 0, 0, 10, 10, r,
colors["menu_background"], true );
void addGameOverSceneItems( SDLPP::Scene &scene,
std::shared_ptr< SDLPP::Renderer > &r,
std::shared_ptr< SDLPP::Font > font ) {
auto bg = std::make_shared< SDLPP::RectangleRender >(
0, 0, 10, 10, r, colors["menu_background"], true );
bg->setId( MENU_BACKGROUND_ID );
bg->setPermanent( true );
scene.addObject( bg );
@ -218,9 +234,11 @@ void addGameOverSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Rendere
scene.addObject( quit );
}
void addOptionsSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer > &r, std::shared_ptr<SDLPP::Font> font ) {
auto bg = std::make_shared< SDLPP::RectangleRender >( 0, 0, 10, 10, r,
colors["menu_background"], true );
void addOptionsSceneItems( SDLPP::Scene &scene,
std::shared_ptr< SDLPP::Renderer > &r,
std::shared_ptr< SDLPP::Font > font ) {
auto bg = std::make_shared< SDLPP::RectangleRender >(
0, 0, 10, 10, r, colors["menu_background"], true );
bg->setId( MENU_BACKGROUND_ID );
bg->setPermanent( true );
scene.addObject( bg );
@ -231,7 +249,9 @@ void addOptionsSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer
scene.addObject( y );
auto color_scheme =
std::make_shared< SDLPP::TextRenderer >( 0.35, 0.3, 0.3, 0.09, r );
color_scheme->setText( *font, "Color scheme: " + color_schemes_names[selected_color_scheme], colors["text"], colors["text_out"], 5 );
color_scheme->setText(
*font, "Color scheme: " + color_schemes_names[selected_color_scheme],
colors["text"], colors["text_out"], 5 );
color_scheme->centerX();
color_scheme->setColor( colors["menu_item_background"] );
color_scheme->setId( MENU_ITEM_ID );
@ -239,14 +259,16 @@ void addOptionsSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer
scene.addObject( color_scheme );
auto shadow =
std::make_shared< SDLPP::TextRenderer >( 0.4, 0.4, 0.2, 0.09, r );
shadow->setText( *font, "Show shadow: YES", colors["text"], colors["text_out"], 5 );
shadow->setText( *font, "Show shadow: YES", colors["text"],
colors["text_out"], 5 );
shadow->centerX();
shadow->setId( MENU_ITEM_ID );
g_options_options.push_back( shadow );
scene.addObject( shadow );
auto show3d =
std::make_shared< SDLPP::TextRenderer >( 0.4, 0.5, 0.2, 0.09, r );
show3d->setText( *font, "Show block texture: NO", colors["text"], colors["text_out"], 5 );
show3d->setText( *font, "Show block texture: NO", colors["text"],
colors["text_out"], 5 );
show3d->centerX();
show3d->setId( MENU_ITEM_ID );
g_options_options.push_back( show3d );
@ -260,25 +282,33 @@ void addOptionsSceneItems( SDLPP::Scene &scene, std::shared_ptr< SDLPP::Renderer
scene.addObject( save );
}
std::shared_ptr<SDLPP::Scene> prepareMainScene(std::shared_ptr<SDLPP::Renderer> renderer, std::shared_ptr<SDLPP::Font> font) {
std::shared_ptr< SDLPP::Scene >
prepareMainScene( std::shared_ptr< SDLPP::Renderer > renderer,
std::shared_ptr< SDLPP::Font > font ) {
auto scene = std::make_shared< SDLPP::Scene >( renderer );
addMainSceneItems( *scene, renderer, font );
return scene;
}
std::shared_ptr<SDLPP::Scene> prepareMenuScene(std::shared_ptr<SDLPP::Renderer> renderer, std::shared_ptr<SDLPP::Font> font) {
std::shared_ptr< SDLPP::Scene >
prepareMenuScene( std::shared_ptr< SDLPP::Renderer > renderer,
std::shared_ptr< SDLPP::Font > font ) {
auto scene = std::make_shared< SDLPP::Scene >( renderer );
addMenuSceneItems( *scene, renderer, font );
return scene;
}
std::shared_ptr<SDLPP::Scene> prepareGameOverScene(std::shared_ptr<SDLPP::Renderer> renderer, std::shared_ptr<SDLPP::Font> font) {
std::shared_ptr< SDLPP::Scene >
prepareGameOverScene( std::shared_ptr< SDLPP::Renderer > renderer,
std::shared_ptr< SDLPP::Font > font ) {
auto scene = std::make_shared< SDLPP::Scene >( renderer );
addGameOverSceneItems( *scene, renderer, font );
return scene;
}
std::shared_ptr<SDLPP::Scene> prepareOptionsScene(std::shared_ptr<SDLPP::Renderer> renderer, std::shared_ptr<SDLPP::Font> font) {
std::shared_ptr< SDLPP::Scene >
prepareOptionsScene( std::shared_ptr< SDLPP::Renderer > renderer,
std::shared_ptr< SDLPP::Font > font ) {
auto scene = std::make_shared< SDLPP::Scene >( renderer );
addOptionsSceneItems( *scene, renderer, font );
return scene;
@ -386,7 +416,6 @@ void handleKeyUpMain( SDL_Keycode key ) {
}
}
void pollEventsMain( SDLPP::Scene &scene ) {
SDL_Event event;
while ( SDLPP::getSDLEvent( event ) ) {
@ -412,7 +441,9 @@ void pollEventsMain( SDLPP::Scene &scene ) {
}
}
void mainSceneInput( std::shared_ptr< SDLPP::Scene > scene, int base, std::vector<std::shared_ptr<SDLPP::RenderObject>> &line_coliders ) {
void mainSceneInput(
std::shared_ptr< SDLPP::Scene > scene, int base,
std::vector< std::shared_ptr< SDLPP::RenderObject > > &line_coliders ) {
std::lock_guard< std::mutex > guard( g_movement_mutex );
pollEventsMain( *scene );
if ( g_cur_object ) {
@ -482,7 +513,8 @@ void handleKeyDownMenu( SDL_Keycode key ) {
g_menu_select++;
if ( static_cast< size_t >( g_menu_select ) >= g_menu_options.size() )
g_menu_select = 0;
g_menu_options[g_menu_select]->setColor( colors["menu_item_background"] );
g_menu_options[g_menu_select]->setColor(
colors["menu_item_background"] );
break;
case SDLK_w:
case SDLK_UP:
@ -490,7 +522,8 @@ void handleKeyDownMenu( SDL_Keycode key ) {
g_menu_select--;
if ( g_menu_select < 0 )
g_menu_select = g_menu_options.size() - 1;
g_menu_options[g_menu_select]->setColor( colors["menu_item_background"] );
g_menu_options[g_menu_select]->setColor(
colors["menu_item_background"] );
break;
case SDLK_RETURN:
switch ( g_menu_select ) {
@ -539,7 +572,9 @@ void pollEventsMenu() {
}
}
void menuSceneInput( std::shared_ptr< SDLPP::Scene > /*UNUSED*/, int /*UNUSED*/, std::vector<std::shared_ptr<SDLPP::RenderObject>> &/*UNUSED*/ ) {
void menuSceneInput(
std::shared_ptr< SDLPP::Scene > /*UNUSED*/, int /*UNUSED*/,
std::vector< std::shared_ptr< SDLPP::RenderObject > > & /*UNUSED*/ ) {
pollEventsMenu();
}
@ -555,9 +590,11 @@ void handleKeyDownGameOver( SDL_Keycode key ) {
case SDLK_DOWN:
g_game_over_options[g_game_over_select]->unsetColor();
g_game_over_select++;
if ( static_cast<size_t>(g_game_over_select) >= g_game_over_options.size() )
if ( static_cast< size_t >( g_game_over_select ) >=
g_game_over_options.size() )
g_game_over_select = 0;
g_game_over_options[g_game_over_select]->setColor( colors["menu_item_background"] );
g_game_over_options[g_game_over_select]->setColor(
colors["menu_item_background"] );
break;
case SDLK_w:
case SDLK_UP:
@ -565,7 +602,8 @@ void handleKeyDownGameOver( SDL_Keycode key ) {
g_game_over_select--;
if ( g_game_over_select < 0 )
g_game_over_select = g_game_over_options.size() - 1;
g_game_over_options[g_game_over_select]->setColor( colors["menu_item_background"] );
g_game_over_options[g_game_over_select]->setColor(
colors["menu_item_background"] );
break;
case SDLK_RETURN:
switch ( g_game_over_select ) {
@ -604,7 +642,9 @@ void pollEventsGameOver() {
}
}
void gameOverSceneInput( std::shared_ptr< SDLPP::Scene > /*UNUSED*/, int /*UNUSED*/, std::vector<std::shared_ptr<SDLPP::RenderObject>> &/*UNUSED*/ ) {
void gameOverSceneInput(
std::shared_ptr< SDLPP::Scene > /*UNUSED*/, int /*UNUSED*/,
std::vector< std::shared_ptr< SDLPP::RenderObject > > & /*UNUSED*/ ) {
pollEventsGameOver();
}
@ -627,9 +667,11 @@ void handleKeyDownOptions( SDL_Keycode key ) {
case SDLK_DOWN:
g_options_options[g_options_select]->unsetColor();
g_options_select++;
if ( static_cast<size_t>(g_options_select) >= g_options_options.size() )
if ( static_cast< size_t >( g_options_select ) >=
g_options_options.size() )
g_options_select = 0;
g_options_options[g_options_select]->setColor( colors["menu_item_background"] );
g_options_options[g_options_select]->setColor(
colors["menu_item_background"] );
break;
case SDLK_w:
case SDLK_UP:
@ -637,26 +679,37 @@ void handleKeyDownOptions( SDL_Keycode key ) {
g_options_select--;
if ( g_options_select < 0 )
g_options_select = g_options_options.size() - 1;
g_options_options[g_options_select]->setColor( colors["menu_item_background"] );
g_options_options[g_options_select]->setColor(
colors["menu_item_background"] );
break;
case SDLK_RIGHT:
case SDLK_d:
switch ( g_options_select ) {
case OPTIONS_MENU_COLOR_SCHEME:
selected_color_scheme++;
if(static_cast<size_t>(selected_color_scheme) >= color_schemes_names.size())
if ( static_cast< size_t >( selected_color_scheme ) >=
color_schemes_names.size() )
selected_color_scheme = 0;
std::dynamic_pointer_cast<SDLPP::TextRenderer>(g_options_options[OPTIONS_MENU_COLOR_SCHEME])->changeText("Color scheme: " + color_schemes_names[selected_color_scheme]);
std::dynamic_pointer_cast< SDLPP::TextRenderer >(
g_options_options[OPTIONS_MENU_COLOR_SCHEME] )
->changeText( "Color scheme: " +
color_schemes_names[selected_color_scheme] );
g_update_colors = true;
break;
case OPTIONS_MENU_SHADOW:
g_show_shadow = !g_show_shadow;
std::dynamic_pointer_cast<SDLPP::TextRenderer>(g_options_options[OPTIONS_MENU_SHADOW])->changeText(std::string("Show shadow: ") + (g_show_shadow ? "YES" : "NO"));
std::dynamic_pointer_cast< SDLPP::TextRenderer >(
g_options_options[OPTIONS_MENU_SHADOW] )
->changeText( std::string( "Show shadow: " ) +
( g_show_shadow ? "YES" : "NO" ) );
g_update_colors = true;
break;
case OPTIONS_MENU_3D:
g_show_3d = !g_show_3d;
std::dynamic_pointer_cast<SDLPP::TextRenderer>(g_options_options[OPTIONS_MENU_3D])->changeText(std::string("Show block texture: ") + (g_show_3d ? "YES" : "NO"));
std::dynamic_pointer_cast< SDLPP::TextRenderer >(
g_options_options[OPTIONS_MENU_3D] )
->changeText( std::string( "Show block texture: " ) +
( g_show_3d ? "YES" : "NO" ) );
g_update_colors = true;
default:
break;
@ -669,17 +722,26 @@ void handleKeyDownOptions( SDL_Keycode key ) {
if ( selected_color_scheme == 0 )
selected_color_scheme = color_schemes_names.size();
selected_color_scheme--;
std::dynamic_pointer_cast<SDLPP::TextRenderer>(g_options_options[OPTIONS_MENU_COLOR_SCHEME])->changeText("Color scheme: " + color_schemes_names[selected_color_scheme]);
std::dynamic_pointer_cast< SDLPP::TextRenderer >(
g_options_options[OPTIONS_MENU_COLOR_SCHEME] )
->changeText( "Color scheme: " +
color_schemes_names[selected_color_scheme] );
g_update_colors = true;
break;
case OPTIONS_MENU_SHADOW:
g_show_shadow = !g_show_shadow;
std::dynamic_pointer_cast<SDLPP::TextRenderer>(g_options_options[OPTIONS_MENU_SHADOW])->changeText(std::string("Show shadow: ") + (g_show_shadow ? "YES" : "NO"));
std::dynamic_pointer_cast< SDLPP::TextRenderer >(
g_options_options[OPTIONS_MENU_SHADOW] )
->changeText( std::string( "Show shadow: " ) +
( g_show_shadow ? "YES" : "NO" ) );
g_update_colors = true;
break;
case OPTIONS_MENU_3D:
g_show_3d = !g_show_3d;
std::dynamic_pointer_cast<SDLPP::TextRenderer>(g_options_options[OPTIONS_MENU_3D])->changeText(std::string("Show block texture: ") + (g_show_3d ? "YES" : "NO"));
std::dynamic_pointer_cast< SDLPP::TextRenderer >(
g_options_options[OPTIONS_MENU_3D] )
->changeText( std::string( "Show block texture: " ) +
( g_show_3d ? "YES" : "NO" ) );
g_update_colors = true;
default:
break;
@ -727,6 +789,8 @@ void pollEventsOptions() {
}
}
void optionsSceneInput( std::shared_ptr< SDLPP::Scene > /*UNUSED*/, int /*UNUSED*/, std::vector<std::shared_ptr<SDLPP::RenderObject>> &/*UNUSED*/ ) {
void optionsSceneInput(
std::shared_ptr< SDLPP::Scene > /*UNUSED*/, int /*UNUSED*/,
std::vector< std::shared_ptr< SDLPP::RenderObject > > & /*UNUSED*/ ) {
pollEventsOptions();
}

34
tetris/scenes.hpp
View File

@ -1,16 +1,32 @@
#ifndef TETRIS_MAIN_SCENE
#define TETRIS_MAIN_SCENE
#include "../sdlpp.hpp"
#include "../sdlpp/sdlpp.hpp"
std::shared_ptr<SDLPP::Scene> prepareMainScene(std::shared_ptr<SDLPP::Renderer> renderer, std::shared_ptr<SDLPP::Font> font);
std::shared_ptr<SDLPP::Scene> prepareMenuScene(std::shared_ptr<SDLPP::Renderer> renderer, std::shared_ptr<SDLPP::Font> font);
std::shared_ptr<SDLPP::Scene> prepareGameOverScene(std::shared_ptr<SDLPP::Renderer> renderer, std::shared_ptr<SDLPP::Font> font);
std::shared_ptr<SDLPP::Scene> prepareOptionsScene(std::shared_ptr<SDLPP::Renderer> renderer, std::shared_ptr<SDLPP::Font> font);
std::shared_ptr< SDLPP::Scene >
prepareMainScene( std::shared_ptr< SDLPP::Renderer > renderer,
std::shared_ptr< SDLPP::Font > font );
std::shared_ptr< SDLPP::Scene >
prepareMenuScene( std::shared_ptr< SDLPP::Renderer > renderer,
std::shared_ptr< SDLPP::Font > font );
std::shared_ptr< SDLPP::Scene >
prepareGameOverScene( std::shared_ptr< SDLPP::Renderer > renderer,
std::shared_ptr< SDLPP::Font > font );
std::shared_ptr< SDLPP::Scene >
prepareOptionsScene( std::shared_ptr< SDLPP::Renderer > renderer,
std::shared_ptr< SDLPP::Font > font );
void mainSceneInput( std::shared_ptr< SDLPP::Scene > scene, int base, std::vector<std::shared_ptr<SDLPP::RenderObject>> &line_coliders );
void menuSceneInput( std::shared_ptr< SDLPP::Scene > scene, int base, std::vector<std::shared_ptr<SDLPP::RenderObject>> &line_coliders );
void gameOverSceneInput( std::shared_ptr< SDLPP::Scene > scene, int base, std::vector<std::shared_ptr<SDLPP::RenderObject>> &line_coliders );
void optionsSceneInput( std::shared_ptr< SDLPP::Scene > scene, int base, std::vector<std::shared_ptr<SDLPP::RenderObject>> &line_coliders );
void mainSceneInput(
std::shared_ptr< SDLPP::Scene > scene, int base,
std::vector< std::shared_ptr< SDLPP::RenderObject > > &line_coliders );
void menuSceneInput(
std::shared_ptr< SDLPP::Scene > scene, int base,
std::vector< std::shared_ptr< SDLPP::RenderObject > > &line_coliders );
void gameOverSceneInput(
std::shared_ptr< SDLPP::Scene > scene, int base,
std::vector< std::shared_ptr< SDLPP::RenderObject > > &line_coliders );
void optionsSceneInput(
std::shared_ptr< SDLPP::Scene > scene, int base,
std::vector< std::shared_ptr< SDLPP::RenderObject > > &line_coliders );
#endif

23
tetris/tetris.cpp
View File

@ -1,4 +1,4 @@
#include "../sdlpp.hpp"
#include "../sdlpp/sdlpp.hpp"
#include "config.hpp"
#include "custom_classes.hpp"
#include "scenes.hpp"
@ -19,7 +19,8 @@
std::vector< std::shared_ptr< SDLPP::RenderObject > > line_coliders{};
void updateScore( std::shared_ptr< SDLPP::Font > font ) {
g_score_texture->setText( *font, std::to_string( g_score ), colors["text"], colors["text_out"], 5 );
g_score_texture->setText( *font, std::to_string( g_score ), colors["text"],
colors["text_out"], 5 );
}
void doInput() {
@ -35,15 +36,18 @@ void doInput() {
}
void prepareShadowColider( std::shared_ptr< SDLPP::Renderer > r ) {
g_shadow_colider = std::make_shared< SDLPP::RectangleRender >( 0, TOP_BORDER, BLOCK_SIZE, BOTTOM_BORDER - TOP_BORDER, r );
g_shadow_colider->addCollision(SDLPP::Rect( 0.1, 0.01, 0.8, 0.98 ));
g_shadow_colider = std::make_shared< SDLPP::RectangleRender >(
0, TOP_BORDER, BLOCK_SIZE, BOTTOM_BORDER - TOP_BORDER, r );
g_shadow_colider->addCollision(
SDLPP::RectColider( 0.1, 0.01, 0.8, 0.98 ) );
g_shadow_colider->setId( COLIDER_ID );
g_shadow_colider->setStatic();
g_shadow_colider->centerX();
}
#ifdef _WIN32
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR szCmdLine, int nCmdShow) {
int WINAPI wWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
PWSTR szCmdLine, int nCmdShow ) {
#else
int main() {
#endif
@ -60,7 +64,8 @@ int main() {
g_main_scene = prepareMainScene( renderer, g_font );
line_coliders = g_main_scene->getObjects( { COLIDER_ID } );
g_score_texture = std::dynamic_pointer_cast<SDLPP::TextRenderer>(g_main_scene->getObjects( {SCORE_TEXTURE_ID} )[0]);
g_score_texture = std::dynamic_pointer_cast< SDLPP::TextRenderer >(
g_main_scene->getObjects( { SCORE_TEXTURE_ID } )[0] );
g_active_scenes.push_back( g_main_scene );
g_main_scene->saveScene();
@ -90,7 +95,8 @@ int main() {
if ( !g_cur_object && g_checked_line ) {
std::lock_guard< std::mutex > guard( g_movement_mutex );
if ( !g_next_object ) {
g_next_object = g_tetrisFunctions[std::rand() / ( ( RAND_MAX + 1u ) / 7 )](
g_next_object =
g_tetrisFunctions[std::rand() / ( ( RAND_MAX + 1u ) / 7 )](
g_main_scene->getRendererShared(), g_main_scene );
g_next_object->setPos( 0.9, 0.5 );
}
@ -119,7 +125,8 @@ int main() {
}
}
g_next_object.reset();
g_next_object = g_tetrisFunctions[rand_index]( renderer, g_main_scene );
g_next_object =
g_tetrisFunctions[rand_index]( renderer, g_main_scene );
g_next_object->setPos( 0.9, 0.5 );
g_checked_line = false;
}