Crylia/Tetris_SDL
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

finish title screen, fix game logic, add textures, somehow forgot the T tetromino lol

Browse Source
This commit is contained in:
Rene Kievits
2024-10-14 22:45:46 +02:00
parent 190f81176d
commit 24c8c3fe2c
25 changed files with 399 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

263
src/Renderer.cpp
View File

@@ -1,18 +1,27 @@
#include "Renderer.hpp"
#include <iostream>
Renderer::Renderer(shared_ptr<SDL_Renderer> renderer) : renderer(renderer), blockSize(30) {
Renderer::Renderer(shared_ptr<SDL_Renderer> renderer, int w, int h) : renderer(renderer), blockSize(30), windowHeight(h), windowWidth(w) {
setRenderer(renderer);
}
void Renderer::setRenderer(shared_ptr<SDL_Renderer> renderer) {
this->renderer = renderer;
loadTexture("/home/crylia/Dokumente/git/tetris_sdl/assets/single.png", TetrominoShape::I);
loadTexture("/home/crylia/Dokumente/git/tetris_sdl/assets/single.png", TetrominoShape::J);
loadTexture("/home/crylia/Dokumente/git/tetris_sdl/assets/single.png", TetrominoShape::L);
loadTexture("/home/crylia/Dokumente/git/tetris_sdl/assets/single.png", TetrominoShape::S);
loadTexture("/home/crylia/Dokumente/git/tetris_sdl/assets/single.png", TetrominoShape::O);
loadTexture("/home/crylia/Dokumente/git/tetris_sdl/assets/single.png", TetrominoShape::Z);
loadTexture("assets/single.png", TetrisAssets::SINGLE);
loadTexture("assets/border.png", TetrisAssets::BORDER);
loadTexture("assets/J.png", TetrisAssets::J);
loadTexture("assets/L.png", TetrisAssets::L);
loadTexture("assets/T.png", TetrisAssets::T);
loadTexture("assets/O.png", TetrisAssets::O);
loadTexture("assets/S.png", TetrisAssets::S);
loadTexture("assets/Z.png", TetrisAssets::Z);
loadTexture("assets/I_MID.png", TetrisAssets::I);
loadTexture("assets/I_END.png", TetrisAssets::I_END);
loadTexture("assets/I_MID.png", TetrisAssets::I_MID);
loadTexture("assets/I_START.png", TetrisAssets::I_START);
loadTexture("assets/I_ENDR.png", TetrisAssets::I_ENDR);
loadTexture("assets/I_MIDR.png", TetrisAssets::I_MIDR);
loadTexture("assets/I_STARTR.png", TetrisAssets::I_STARTR);
}
void Renderer::renderBoard(const GameBoard& gameBoard) {
@@ -29,14 +38,22 @@ void Renderer::drawScoreboard(int score, int level) {
}
void Renderer::drawGrid(const GameBoard& board) {
SDL_SetRenderDrawColor(renderer.get( ), 100, 100, 100, 255);
int borderThickness = 10, gridThickness = 1;
int innerBorderThickness = blockSize / 4;
int w = board.getLockedTetrominos( )[0].size( ), h = board.getLockedTetrominos( ).size( );
for (int x = 0; x <= w; ++x)
SDL_RenderDrawLine(renderer.get( ), x * blockSize, 0, x * blockSize, h * blockSize);
int w = board.getLockedTetrominos( )[0].size( );
int h = board.getLockedTetrominos( ).size( );
for (int y = 0; y <= h; ++y)
SDL_RenderDrawLine(renderer.get( ), 0, y * blockSize, w * blockSize, y * blockSize);
int totalWidth = w * blockSize;
int totalHeight = h * blockSize;
for (int y = 0; y < (h + (innerBorderThickness * h)); ++y) {
SDL_Rect leftBlock = { offsetX - blockSize, offsetY + y * blockSize, blockSize, blockSize };
renderTexture(TetrisAssets::BORDER, leftBlock.x, leftBlock.y - (innerBorderThickness * y + 1), leftBlock.w, leftBlock.h);
SDL_Rect rightBlock = { offsetX + totalWidth, offsetY + y * blockSize, blockSize, blockSize };
renderTexture(TetrisAssets::BORDER, rightBlock.x, rightBlock.y - (innerBorderThickness * y + 1), rightBlock.w, rightBlock.h);
}
}
void Renderer::drawLockedBlocks(const GameBoard& gameBoard) {
@@ -47,16 +64,19 @@ void Renderer::drawLockedBlocks(const GameBoard& gameBoard) {
for (int col = 0; col < lockedTetrominos[row].size( ); ++col) {
int blockType = lockedTetrominos[row][col];
if (blockType != 0) {
SDL_Rect block = { col * blockSize, row * blockSize, blockSize, blockSize };
SDL_Rect block = { offsetX + col * blockSize, offsetY + row * blockSize, blockSize, blockSize };
SDL_SetTextureBlendMode(textures[TetrominoShape::I], SDL_BLENDMODE_BLEND);
TetrominoShape shape = static_cast<TetrominoShape>(blockType - 1);
TetrisAssets asset = shapeToAsset(shape);
SDL_Color color = lockedColors[row][col];
if (textures[TetrominoShape::I]) {
SDL_SetTextureColorMod(textures[TetrominoShape::I], color.r, color.g, color.b);
renderTexture(TetrominoShape::I, block.x, block.y, block.w, block.h);
if (textures[asset]) {
SDL_Color color = lockedColors[row][col];
SDL_SetTextureBlendMode(textures[asset], SDL_BLENDMODE_BLEND);
SDL_SetTextureColorMod(textures[asset], color.r, color.g, color.b);
renderTexture(asset, block.x, block.y, block.w, block.h);
} else {
SDL_SetRenderDrawColor(renderer.get( ), color.r, color.g, color.b, 255);
SDL_Log("Texture not found for asset: %d", asset);
SDL_SetRenderDrawColor(renderer.get( ), 255, 0, 0, 255);
SDL_RenderFillRect(renderer.get( ), &block);
}
}
@@ -64,52 +84,203 @@ void Renderer::drawLockedBlocks(const GameBoard& gameBoard) {
}
}
TetrisAssets Renderer::shapeToAsset(const TetrominoShape shape) {
switch (shape) {
case TetrominoShape::I:
return TetrisAssets::I;
case TetrominoShape::O:
return TetrisAssets::O;
case TetrominoShape::T:
return TetrisAssets::T;
case TetrominoShape::J:
return TetrisAssets::J;
case TetrominoShape::L:
return TetrisAssets::L;
case TetrominoShape::S:
return TetrisAssets::S;
case TetrominoShape::Z:
return TetrisAssets::Z;
case TetrominoShape::I_END:
return TetrisAssets::I_END;
case TetrominoShape::I_START:
return TetrisAssets::I_START;
case TetrominoShape::I_MID:
return TetrisAssets::I_MID;
case TetrominoShape::I_ENDR:
return TetrisAssets::I_ENDR;
case TetrominoShape::I_STARTR:
return TetrisAssets::I_STARTR;
case TetrominoShape::I_MIDR:
return TetrisAssets::I_MIDR;
default:
break;
}
}
void Renderer::drawTetromino(const Tetromino& tetromino) {
const auto& shape = tetromino.getShape( );
int x = tetromino.getX( ), y = tetromino.getY( );
auto t = tetromino.getTexture( );
double angle = tetromino.getRotationAngle( );
SDL_SetTextureBlendMode(textures[t], SDL_BLENDMODE_BLEND);
SDL_Color color = tetromino.getColor( );
SDL_SetTextureColorMod(textures[t], color.r, color.g, color.b);
TetrominoShape tetrominoShape = tetromino.getShapeEnumn( );
for (int row = 0; row < shape.size( ); ++row) {
for (int col = 0; col < shape[row].size( ); ++col) {
if (shape[row][col] != 0) {
SDL_Rect destRect = { (x + col) * blockSize, (y + row) * blockSize, blockSize, blockSize };
SDL_Point center = { blockSize / 2, blockSize / 2 };
SDL_RenderCopyEx(renderer.get( ), textures[t], nullptr, &destRect, angle, &center, SDL_FLIP_NONE);
SDL_SetTextureBlendMode(textures[shapeToAsset(tetrominoShape)], SDL_BLENDMODE_BLEND);
SDL_Color color = tetromino.getColor( );
SDL_SetTextureColorMod(textures[shapeToAsset(tetrominoShape)], color.r, color.g, color.b);
if (tetrominoShape == TetrominoShape::I) {
SDL_SetTextureColorMod(textures[TetrisAssets::I_START], color.r, color.g, color.b);
SDL_SetTextureColorMod(textures[TetrisAssets::I_MID], color.r, color.g, color.b);
SDL_SetTextureColorMod(textures[TetrisAssets::I_END], color.r, color.g, color.b);
if (angle == 90) {
for (int i = 0; i < 4; ++i) {
SDL_Rect destRect = { offsetX + (x + i) * blockSize, offsetY + y * blockSize, blockSize, blockSize };
SDL_RenderCopyEx(renderer.get( ), textures[TetrisAssets::I_MID], nullptr, &destRect, angle, nullptr, SDL_FLIP_NONE);
}
SDL_Rect startRect = { offsetX + (x + 0) * blockSize, offsetY + y * blockSize, blockSize, blockSize };
SDL_RenderCopyEx(renderer.get( ), textures[TetrisAssets::I_START], nullptr, &startRect, angle, nullptr, SDL_FLIP_NONE);
SDL_Rect endRect = { offsetX + (x + 3) * blockSize, offsetY + y * blockSize, blockSize, blockSize };
SDL_RenderCopyEx(renderer.get( ), textures[TetrisAssets::I_END], nullptr, &endRect, angle, nullptr, SDL_FLIP_NONE);
} else if (angle == 270) {
for (int i = 0; i < 4; ++i) {
SDL_Rect destRect = { offsetX + (x + i) * blockSize, offsetY + y * blockSize, blockSize, blockSize };
SDL_RenderCopyEx(renderer.get( ), textures[TetrisAssets::I_MID], nullptr, &destRect, angle, nullptr, SDL_FLIP_NONE);
}
SDL_Rect startRect = { offsetX + (x + 0) * blockSize, offsetY + y * blockSize, blockSize, blockSize };
SDL_RenderCopyEx(renderer.get( ), textures[TetrisAssets::I_END], nullptr, &startRect, angle, nullptr, SDL_FLIP_NONE);
SDL_Rect endRect = { offsetX + (x + 3) * blockSize, offsetY + y * blockSize, blockSize, blockSize };
SDL_RenderCopyEx(renderer.get( ), textures[TetrisAssets::I_START], nullptr, &endRect, angle, nullptr, SDL_FLIP_NONE);
} else {
SDL_Rect destRect1 = { offsetX + (x + 0) * blockSize, offsetY + (y + 0) * blockSize, blockSize, blockSize };
SDL_Rect destRect2 = { offsetX + (x + 0) * blockSize, offsetY + (y + 1) * blockSize, blockSize, blockSize };
SDL_Rect destRect3 = { offsetX + (x + 0) * blockSize, offsetY + (y + 2) * blockSize, blockSize, blockSize };
SDL_Rect destRect4 = { offsetX + (x + 0) * blockSize, offsetY + (y + 3) * blockSize, blockSize, blockSize };
renderTexture(TetrisAssets::I_END, destRect1.x, destRect1.y, destRect1.w, destRect1.h);
renderTexture(TetrisAssets::I_MID, destRect2.x, destRect2.y, destRect2.w, destRect2.h);
renderTexture(TetrisAssets::I_MID, destRect3.x, destRect3.y, destRect3.w, destRect3.h);
renderTexture(TetrisAssets::I_START, destRect4.x, destRect4.y, destRect4.w, destRect4.h);
}
} else {
for (int row = 0; row < shape.size( ); ++row) {
for (int col = 0; col < shape[row].size( ); ++col) {
if (shape[row][col] != 0) {
SDL_Rect destRect = { offsetX + (x + col) * blockSize, offsetY + (y + row) * blockSize, blockSize, blockSize };
SDL_Point center = { blockSize / 2, blockSize / 2 };
SDL_RenderCopy(renderer.get( ), textures[shapeToAsset(tetrominoShape)], nullptr, &destRect);
}
}
}
}
}
bool Renderer::loadTexture(const string& filePath, const TetrominoShape shape) {
bool Renderer::loadTexture(const string& filePath, const TetrisAssets asset) {
SDL_Texture* texture = IMG_LoadTexture(renderer.get( ), filePath.c_str( ));
if (!texture) {
SDL_Log("Failed to load Texture: %s\n%s", filePath, SDL_GetError( ));
return false;
}
textures[shape] = texture;
textures[asset] = texture;
return true;
}
void Renderer::renderTexture(const TetrominoShape shape, int x, int y, int width, int height) {
void Renderer::renderTexture(const TetrisAssets asset, int x, int y, int width, int height) {
SDL_Rect destRect{ x,y,width,height };
SDL_RenderCopy(renderer.get( ), textures[shape], nullptr, &destRect);
SDL_RenderCopy(renderer.get( ), textures[asset], nullptr, &destRect);
}
void Renderer::renderStartScreen( ) {
SDL_SetRenderDrawColor(renderer.get( ), 0, 0, 0, 255);
SDL_SetRenderDrawColor(renderer.get( ), 248, 248, 248, 255);
SDL_RenderClear(renderer.get( ));
renderText("Tetris", 100, 100, 128, SDL_Color{ 200,200,200 });
int borderThickness = 20;
SDL_Rect borderRect = {
borderThickness,
borderThickness,
windowWidth - 2 * borderThickness,
windowHeight - 2 * borderThickness
};
SDL_SetRenderDrawColor(renderer.get( ), 0, 0, 0, 255);
SDL_RenderDrawRect(renderer.get( ), &borderRect);
SDL_Surface* titleSurface = IMG_Load("assets/title.png");
if (!titleSurface) {
SDL_Log("Failed to load title surface: %s", SDL_GetError( ));
return;
}
auto titleTexture = SDL_CreateTextureFromSurface(renderer.get( ), titleSurface);
SDL_FreeSurface(titleSurface);
if (!titleTexture) {
SDL_Log("Failed to create title texture: %s", SDL_GetError( ));
return;
}
float titleScaleFactor = 0.5f;
int titleWidth = static_cast<int>(windowWidth * titleScaleFactor);
int titleHeight = static_cast<int>(titleWidth * 0.315f);
SDL_Rect titleRect = {
(windowWidth / 2) - (titleWidth / 2),
static_cast<int>(windowHeight * 0.2f),
titleWidth,
titleHeight
};
SDL_RenderCopy(renderer.get( ), titleTexture, nullptr, &titleRect);
SDL_DestroyTexture(titleTexture);
SDL_Surface* titleBg = IMG_Load("assets/title_bg.png");
if (!titleBg) {
SDL_Log("Failed to load background surface: %s", SDL_GetError( ));
return;
}
auto titleBgTexture = SDL_CreateTextureFromSurface(renderer.get( ), titleBg);
int originalBgWidth = titleBg->w;
int originalBgHeight = titleBg->h;
SDL_FreeSurface(titleBg);
if (!titleBgTexture) {
SDL_Log("Failed to create background texture: %s", SDL_GetError( ));
return;
}
float bgScaleFactor = 0.8f;
int titleBgWidth = static_cast<int>(windowWidth * bgScaleFactor);
int titleBgHeight = static_cast<int>(titleBgWidth * (static_cast<float>(originalBgHeight) / originalBgWidth));
if (titleBgHeight > windowHeight * 0.4f) {
titleBgHeight = static_cast<int>(windowHeight * 0.4f);
titleBgWidth = static_cast<int>(titleBgHeight * (static_cast<float>(originalBgWidth) / originalBgHeight));
}
SDL_Rect titleBgRect = {
(windowWidth / 2) - (titleBgWidth / 2),
static_cast<int>(windowHeight * 0.5f),
titleBgWidth,
titleBgHeight
};
SDL_RenderCopy(renderer.get( ), titleBgTexture, nullptr, &titleBgRect);
SDL_DestroyTexture(titleBgTexture);
int w, h;
TTF_Font* font = TTF_OpenFont("assets/tetris-gb.ttf", 16);
TTF_SizeText(font, "PRESS START", &w, &h);
TTF_CloseFont(font);
renderText("press G to start", (windowWidth / 2) - (w / 2), windowHeight - 100, 16, SDL_Color{ 0, 0, 0 });
SDL_RenderPresent(renderer.get( ));
}
void Renderer::renderGameOver(int score, int level) {
SDL_SetRenderDrawColor(renderer.get( ), 0, 0, 0, 128);
SDL_RenderClear(renderer.get( ));
@@ -123,7 +294,7 @@ void Renderer::renderGameOver(int score, int level) {
}
void Renderer::renderText(string text, int x, int y, int size, SDL_Color color) {
TTF_Font* font = TTF_OpenFont("/usr/share/fonts/TTF/OpenSans-Regular.ttf", size);
TTF_Font* font = TTF_OpenFont("assets/tetris-gb.ttf", size);
SDL_Surface* surface = TTF_RenderText_Solid(font, text.c_str( ), color);
if (!surface) {
SDL_Log("Failed to create surface: %s", TTF_GetError( ));
@@ -149,3 +320,21 @@ void Renderer::renderText(string text, int x, int y, int size, SDL_Color color)
SDL_DestroyTexture(texture);
TTF_CloseFont(font);
}
const int Renderer::getBlockSize( ) const { return blockSize; }
void Renderer::setBlockSize(int newBlockSize) { blockSize = newBlockSize; }
void Renderer::setOffset(int newX, int newY) {
offsetX = newX;
offsetY = newY;
}
const int Renderer::getOffsetX( ) const { return offsetX; }
const int Renderer::getOffsetY( ) const { return offsetY; }
void Renderer::setWindowSize(int w, int h) {
windowWidth = w;
windowHeight = h;
}