jaildesigner-jailgames/coffee_crisis_arcade_edition
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 13 Wiki Activity

Abans de renombrar player.cpp

Browse Source
This commit is contained in:
Sergio
2024-10-11 21:58:59 +02:00
parent 3a6950f3a4
commit d50cf23721
4 changed files with 332 additions and 339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

288
source/scoreboard.cpp
View File

@@ -12,67 +12,67 @@
#include "texture.h" // for Texture
// [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
Scoreboard *Scoreboard::scoreboard = nullptr;
Scoreboard *Scoreboard::scoreboard_ = nullptr;
// [SINGLETON] Crearemos el objeto scoreboard con esta función estática
// [SINGLETON] Crearemos el objeto score_board con esta función estática
void Scoreboard::init(SDL_Renderer *renderer)
{
Scoreboard::scoreboard = new Scoreboard(renderer);
Scoreboard::scoreboard_ = new Scoreboard(renderer);
}
// [SINGLETON] Destruiremos el objeto scoreboard con esta función estática
// [SINGLETON] Destruiremos el objeto score_board con esta función estática
void Scoreboard::destroy()
{
delete Scoreboard::scoreboard;
delete Scoreboard::scoreboard_;
}
// [SINGLETON] Con este método obtenemos el objeto scoreboard y podemos trabajar con él
// [SINGLETON] Con este método obtenemos el objeto score_board y podemos trabajar con él
Scoreboard *Scoreboard::get()
{
return Scoreboard::scoreboard;
return Scoreboard::scoreboard_;
}
// Constructor
Scoreboard::Scoreboard(SDL_Renderer *renderer)
: renderer(renderer)
: renderer_(renderer)
{
// Inicializa punteros
gamePowerMeterTexture = nullptr;
powerMeterSprite = nullptr;
textScoreBoard = nullptr;
game_power_meter_texture_ = nullptr;
power_meter_sprite_ = nullptr;
text_scoreboard_ = nullptr;
// Inicializa variables
stage = 1;
for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
{
name[i] = "";
recordName[i] = "";
selectorPos[i] = 0;
score[i] = 0;
mult[i] = 0;
continueCounter[i] = 0;
name_[i] = "";
record_name_[i] = "";
selector_pos_[i] = 0;
score_[i] = 0;
mult_[i] = 0;
continue_counter_[i] = 0;
}
hiScore = 0;
power = 0;
hiScoreName = "";
color = {0, 0, 0};
rect = {0, 0, 320, 40};
panel[SCOREBOARD_LEFT_PANEL].mode = ScoreboardMode::SCORE;
panel[SCOREBOARD_RIGHT_PANEL].mode = ScoreboardMode::SCORE;
panel[SCOREBOARD_CENTER_PANEL].mode = ScoreboardMode::STAGE_INFO;
ticks = SDL_GetTicks();
counter = 0;
stage_ = 1;
hi_score_ = 0;
power_ = 0;
hi_score_name_ = "";
color_ = {0, 0, 0};
rect_ = {0, 0, 320, 40};
panel_[SCOREBOARD_LEFT_PANEL].mode = ScoreboardMode::SCORE;
panel_[SCOREBOARD_RIGHT_PANEL].mode = ScoreboardMode::SCORE;
panel_[SCOREBOARD_CENTER_PANEL].mode = ScoreboardMode::STAGE_INFO;
ticks_ = SDL_GetTicks();
counter_ = 0;
// Recalcula las anclas de los elementos
recalculateAnchors();
// Crea objetos
gamePowerMeterTexture = std::make_shared<Texture>(renderer, Asset::get()->get("game_power_meter.png"));
powerMeterSprite = std::make_unique<Sprite>(slot4_2.x - 20, slot4_2.y, 40, 7, gamePowerMeterTexture);
textScoreBoard = std::make_unique<Text>(Asset::get()->get("8bithud.png"), Asset::get()->get("8bithud.txt"), renderer);
game_power_meter_texture_ = std::make_shared<Texture>(renderer_, Asset::get()->get("game_power_meter.png"));
power_meter_sprite_ = std::make_unique<Sprite>(slot4_2_.x - 20, slot4_2_.y, 40, 7, game_power_meter_texture_);
text_scoreboard_ = std::make_unique<Text>(Asset::get()->get("8bithud.png"), Asset::get()->get("8bithud.txt"), renderer_);
// Crea la textura de fondo
background = nullptr;
background_ = nullptr;
createBackgroundTexture();
// Crea las texturas de los paneles
@@ -84,12 +84,12 @@ Scoreboard::Scoreboard(SDL_Renderer *renderer)
Scoreboard::~Scoreboard()
{
if (background)
if (background_)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(background_);
}
for (auto texture : panelTexture)
for (auto texture : panel_texture_)
{
if (texture)
{
@@ -109,10 +109,10 @@ std::string Scoreboard::updateScoreText(int num)
// Actualiza el contador
void Scoreboard::updateCounter()
{
if (SDL_GetTicks() - ticks > SCOREBOARD_TICK_SPEED)
if (SDL_GetTicks() - ticks_ > SCOREBOARD_TICK_SPEED)
{
ticks = SDL_GetTicks();
counter++;
ticks_ = SDL_GetTicks();
counter_++;
}
}
@@ -126,80 +126,80 @@ void Scoreboard::update()
// Pinta el marcador
void Scoreboard::render()
{
SDL_RenderCopy(renderer, background, nullptr, &rect);
SDL_RenderCopy(renderer_, background_, nullptr, &rect_);
}
// Establece el valor de la variable
void Scoreboard::setName(int panel, std::string name)
void Scoreboard::setName(int panel_, std::string name_)
{
this->name[panel] = name;
this->name_[panel_] = name_;
}
// Establece el valor de la variable
void Scoreboard::setRecordName(int panel, std::string recordName)
void Scoreboard::setRecordName(int panel_, std::string record_name_)
{
this->recordName[panel] = recordName;
this->record_name_[panel_] = record_name_;
}
// Establece el valor de la variable
void Scoreboard::setSelectorPos(int panel, int pos)
void Scoreboard::setSelectorPos(int panel_, int pos)
{
selectorPos[panel] = pos;
selector_pos_[panel_] = pos;
}
// Establece el valor de la variable
void Scoreboard::setScore(int panel, int score)
void Scoreboard::setScore(int panel_, int score_)
{
this->score[panel] = score;
this->score_[panel_] = score_;
}
// Establece el valor de la variable
void Scoreboard::setMult(int panel, float mult)
void Scoreboard::setMult(int panel_, float mult_)
{
this->mult[panel] = mult;
this->mult_[panel_] = mult_;
}
// Establece el valor de la variable
void Scoreboard::setContinue(int panel, int value)
void Scoreboard::setContinue(int panel_, int value)
{
continueCounter[panel] = value;
continue_counter_[panel_] = value;
}
// Establece el valor de la variable
void Scoreboard::setStage(int stage)
void Scoreboard::setStage(int stage_)
{
this->stage = stage;
this->stage_ = stage_;
}
// Establece el valor de la variable
void Scoreboard::setHiScore(int hiScore)
void Scoreboard::setHiScore(int hi_score_)
{
this->hiScore = hiScore;
this->hi_score_ = hi_score_;
}
// Establece el valor de la variable
void Scoreboard::setPower(float power)
void Scoreboard::setPower(float power_)
{
this->power = power;
this->power_ = power_;
}
// Establece el valor de la variable
void Scoreboard::setHiScoreName(std::string name)
void Scoreboard::setHiScoreName(std::string name_)
{
hiScoreName = name;
hi_score_name_ = name_;
}
// Establece el valor de la variable
void Scoreboard::setColor(Color color)
void Scoreboard::setColor(Color color_)
{
this->color = color;
this->color_ = color_;
fillBackgroundTexture();
}
// Establece el valor de la variable
void Scoreboard::setPos(SDL_Rect rect)
void Scoreboard::setPos(SDL_Rect rect_)
{
this->rect = rect;
this->rect_ = rect_;
// Recalcula las anclas de los elementos
recalculateAnchors();
@@ -218,42 +218,42 @@ void Scoreboard::setPos(SDL_Rect rect)
void Scoreboard::fillPanelTextures()
{
// Guarda a donde apunta actualmente el renderizador
SDL_Texture *temp = SDL_GetRenderTarget(renderer);
SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
// Genera el contenidoi de cada panel
// Genera el contenidoi de cada panel_
for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
{
// Cambia el destino del renderizador
SDL_SetRenderTarget(renderer, panelTexture[i]);
SDL_SetRenderTarget(renderer_, panel_texture_[i]);
// Dibuja el fondo de la textura
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
SDL_RenderClear(renderer_);
switch (panel[i].mode)
switch (panel_[i].mode)
{
case ScoreboardMode::SCORE:
{
// SCORE
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y, name[i]);
textScoreBoard->writeCentered(slot4_2.x, slot4_2.y, updateScoreText(score[i]));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, name_[i]);
text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
// MULT
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y, lang::getText(55));
textScoreBoard->writeCentered(slot4_4.x, slot4_4.y, std::to_string(mult[i]).substr(0, 3));
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(55));
text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, std::to_string(mult_[i]).substr(0, 3));
break;
}
case ScoreboardMode::DEMO:
{
// DEMO MODE
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y + 4, lang::getText(101));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(101));
// PRESS START TO PLAY
if (counter % 10 < 8)
if (counter_ % 10 < 8)
{
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y - 2, lang::getText(103));
textScoreBoard->writeCentered(slot4_4.x, slot4_4.y - 2, lang::getText(104));
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(103));
text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(104));
}
break;
}
@@ -261,13 +261,13 @@ void Scoreboard::fillPanelTextures()
case ScoreboardMode::WAITING:
{
// GAME OVER
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y + 4, lang::getText(102));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
// PRESS START TO PLAY
if (counter % 10 < 8)
if (counter_ % 10 < 8)
{
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y - 2, lang::getText(103));
textScoreBoard->writeCentered(slot4_4.x, slot4_4.y - 2, lang::getText(104));
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(103));
text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(104));
}
break;
}
@@ -275,13 +275,13 @@ void Scoreboard::fillPanelTextures()
case ScoreboardMode::GAME_OVER:
{
// GAME OVER
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y + 4, lang::getText(102));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
// PLEASE WAIT
if (counter % 10 < 8)
if (counter_ % 10 < 8)
{
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y - 2, lang::getText(114));
textScoreBoard->writeCentered(slot4_4.x, slot4_4.y - 2, lang::getText(115));
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(114));
text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(115));
}
break;
}
@@ -289,58 +289,58 @@ void Scoreboard::fillPanelTextures()
case ScoreboardMode::STAGE_INFO:
{
// STAGE
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y, lang::getText(57) + std::to_string(stage));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, lang::getText(57) + std::to_string(stage_));
// POWERMETER
powerMeterSprite->setSpriteClip(0, 0, 40, 7);
powerMeterSprite->render();
powerMeterSprite->setSpriteClip(40, 0, int(power * 40.0f), 7);
powerMeterSprite->render();
power_meter_sprite_->setSpriteClip(0, 0, 40, 7);
power_meter_sprite_->render();
power_meter_sprite_->setSpriteClip(40, 0, int(power_ * 40.0f), 7);
power_meter_sprite_->render();
// HI-SCORE
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y, lang::getText(56));
textScoreBoard->writeCentered(slot4_4.x, slot4_4.y, hiScoreName + " - " + updateScoreText(hiScore));
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(56));
text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, hi_score_name_ + " - " + updateScoreText(hi_score_));
break;
}
case ScoreboardMode::CONTINUE:
{
// SCORE
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y, name[i]);
textScoreBoard->writeCentered(slot4_2.x, slot4_2.y, updateScoreText(score[i]));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, name_[i]);
text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
// CONTINUE
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y, lang::getText(105));
textScoreBoard->writeCentered(slot4_4.x, slot4_4.y, std::to_string(continueCounter[i]));
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(105));
text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, std::to_string(continue_counter_[i]));
break;
}
case ScoreboardMode::ENTER_NAME:
{
// SCORE
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y, name[i]);
textScoreBoard->writeCentered(slot4_2.x, slot4_2.y, updateScoreText(score[i]));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, name_[i]);
text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
// ENTER NAME
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y, lang::getText(106));
SDL_Rect rect = {enterNamePos.x, enterNamePos.y, 5, 7};
SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xEB, 255);
for (int j = 0; j < (int)recordName[i].size(); ++j)
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(106));
SDL_Rect rect_ = {enter_name_pos_.x, enter_name_pos_.y, 5, 7};
SDL_SetRenderDrawColor(renderer_, 0xFF, 0xFF, 0xEB, 255);
for (int j = 0; j < (int)record_name_[i].size(); ++j)
{
if (j == selectorPos[i])
if (j == selector_pos_[i])
{ // La letra seleccionada se pinta de forma intermitente
if (counter % 3 > 0)
if (counter_ % 3 > 0)
{
SDL_RenderDrawLine(renderer, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
textScoreBoard->write(rect.x, rect.y, recordName[i].substr(j, 1));
SDL_RenderDrawLine(renderer_, rect_.x, rect_.y + rect_.h, rect_.x + rect_.w, rect_.y + rect_.h);
text_scoreboard_->write(rect_.x, rect_.y, record_name_[i].substr(j, 1));
}
}
else
{
SDL_RenderDrawLine(renderer, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
textScoreBoard->write(rect.x, rect.y, recordName[i].substr(j, 1));
SDL_RenderDrawLine(renderer_, rect_.x, rect_.y + rect_.h, rect_.x + rect_.w, rect_.y + rect_.h);
text_scoreboard_->write(rect_.x, rect_.y, record_name_[i].substr(j, 1));
}
rect.x += 7;
rect_.x += 7;
}
break;
}
@@ -351,7 +351,7 @@ void Scoreboard::fillPanelTextures()
}
// Deja el renderizador apuntando donde estaba
SDL_SetRenderTarget(renderer, temp);
SDL_SetRenderTarget(renderer_, temp);
}
// Rellena la textura de fondo
@@ -361,41 +361,41 @@ void Scoreboard::fillBackgroundTexture()
fillPanelTextures();
// Cambia el destino del renderizador
SDL_Texture *temp = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, background);
SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
SDL_SetRenderTarget(renderer_, background_);
// Dibuja el fondo del marcador
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 255);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, color_.r, color_.g, color_.b, 255);
SDL_RenderClear(renderer_);
// Copia las texturas de los paneles
for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
{
SDL_RenderCopy(renderer, panelTexture[i], nullptr, &panel[i].pos);
SDL_RenderCopy(renderer_, panel_texture_[i], nullptr, &panel_[i].pos);
}
// Dibuja la linea que separa la zona de juego del marcador
renderSeparator();
// Deja el renderizador apuntando donde estaba
SDL_SetRenderTarget(renderer, temp);
SDL_SetRenderTarget(renderer_, temp);
}
// Recalcula las anclas de los elementos
void Scoreboard::recalculateAnchors()
{
// Recalcula la posición y el tamaño de los paneles
const float panelWidth = (float)rect.w / (float)SCOREBOARD_MAX_PANELS;
const float panelWidth = (float)rect_.w / (float)SCOREBOARD_MAX_PANELS;
for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
{
panel[i].pos.x = roundf(panelWidth * i);
panel[i].pos.y = 0;
panel[i].pos.w = roundf(panelWidth * (i + 1)) - panel[i].pos.x;
panel[i].pos.h = rect.h;
panel_[i].pos.x = roundf(panelWidth * i);
panel_[i].pos.y = 0;
panel_[i].pos.w = roundf(panelWidth * (i + 1)) - panel_[i].pos.x;
panel_[i].pos.h = rect_.h;
}
// Constantes para definir las zonas del panel: 4 filas y 1 columna
const int rowSize = rect.h / 4;
// Constantes para definir las zonas del panel_: 4 filas y 1 columna
const int rowSize = rect_.h / 4;
const int textHeight = 7;
// Filas
@@ -408,63 +408,63 @@ void Scoreboard::recalculateAnchors()
const int col = panelWidth / 2;
// Slots de 4
slot4_1 = {col, row1};
slot4_2 = {col, row2};
slot4_3 = {col, row3};
slot4_4 = {col, row4};
slot4_1_ = {col, row1};
slot4_2_ = {col, row2};
slot4_3_ = {col, row3};
slot4_4_ = {col, row4};
// Primer cuadrado para poner el nombre de record
const int enterNameLenght = 8 * 7;
enterNamePos.x = (panelWidth - enterNameLenght) / 2;
enterNamePos.y = row4;
enter_name_pos_.x = (panelWidth - enterNameLenght) / 2;
enter_name_pos_.y = row4;
// Recoloca los sprites
if (powerMeterSprite)
if (power_meter_sprite_)
{
powerMeterSprite->setPosX(slot4_2.x - 20);
powerMeterSprite->setPosY(slot4_2.y);
power_meter_sprite_->setPosX(slot4_2_.x - 20);
power_meter_sprite_->setPosY(slot4_2_.y);
}
}
// Establece el modo del marcador
void Scoreboard::setMode(int index, ScoreboardMode mode)
{
panel[index].mode = mode;
panel_[index].mode = mode;
}
// Crea la textura de fondo
void Scoreboard::createBackgroundTexture()
{
// Elimina la textura en caso de existir
if (background)
if (background_)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(background_);
}
// Recrea la textura de fondo
background = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
SDL_SetTextureBlendMode(background, SDL_BLENDMODE_BLEND);
background_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
SDL_SetTextureBlendMode(background_, SDL_BLENDMODE_BLEND);
}
// Crea las texturas de los paneles
void Scoreboard::createPanelTextures()
{
// Elimina las texturas en caso de existir
for (auto texture : panelTexture)
for (auto texture : panel_texture_)
{
if (texture != nullptr)
{
SDL_DestroyTexture(texture);
}
}
panelTexture.clear();
panel_texture_.clear();
// Crea las texturas para cada panel
// Crea las texturas para cada panel_
for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
{
SDL_Texture *tex = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, panel[i].pos.w, panel[i].pos.h);
SDL_Texture *tex = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, panel_[i].pos.w, panel_[i].pos.h);
SDL_SetTextureBlendMode(tex, SDL_BLENDMODE_BLEND);
panelTexture.push_back(tex);
panel_texture_.push_back(tex);
}
}
@@ -472,6 +472,6 @@ void Scoreboard::createPanelTextures()
void Scoreboard::renderSeparator()
{
// Dibuja la linea que separa el marcador de la zona de juego
SDL_SetRenderDrawColor(renderer, separator_color.r, separator_color.g, separator_color.b, 255);
SDL_RenderDrawLine(renderer, 0, 0, rect.w, 0);
SDL_SetRenderDrawColor(renderer_, separator_color.r, separator_color.g, separator_color.b, 255);
SDL_RenderDrawLine(renderer_, 0, 0, rect_.w, 0);
}

56
source/scoreboard.h
View File

@@ -19,7 +19,7 @@ constexpr int SCOREBOARD_MAX_PANELS = 3;
constexpr int SCOREBOARD_TICK_SPEED = 100;
// Enums
enum class ScoreboardMode
enum class ScoreboardMode : int
{
SCORE,
STAGE_INFO,
@@ -32,7 +32,7 @@ enum class ScoreboardMode
};
// Structs
struct panel_t
struct Panel
{
ScoreboardMode mode; // Modo en el que se encuentra el panel
SDL_Rect pos; // Posición donde dibujar el panel dentro del marcador
@@ -43,38 +43,38 @@ class Scoreboard
{
private:
// [SINGLETON] Objeto scoreboard privado para Don Melitón
static Scoreboard *scoreboard;
static Scoreboard *scoreboard_;
// Objetos y punteros
SDL_Renderer *renderer; // El renderizador de la ventana
SDL_Renderer *renderer_; // El renderizador de la ventana
std::shared_ptr<Texture> gamePowerMeterTexture; // Textura con el marcador de poder de la fase
std::unique_ptr<Sprite> powerMeterSprite; // Sprite para el medidor de poder de la fase
std::unique_ptr<Text> textScoreBoard; // Fuente para el marcador del juego
std::shared_ptr<Texture> game_power_meter_texture_; // Textura con el marcador de poder de la fase
std::unique_ptr<Sprite> power_meter_sprite_; // Sprite para el medidor de poder de la fase
std::unique_ptr<Text> text_scoreboard_; // Fuente para el marcador del juego
SDL_Texture *background; // Textura para dibujar el marcador
std::vector<SDL_Texture *> panelTexture; // Texturas para dibujar cada panel;
SDL_Texture *background_; // Textura para dibujar el marcador
std::vector<SDL_Texture *> panel_texture_; // Texturas para dibujar cada panel
// Variables
int stage; // Número de fase actual
std::string name[SCOREBOARD_MAX_PANELS]; // Nom de cada jugador
std::string recordName[SCOREBOARD_MAX_PANELS]; // Nombre introducido para la tabla de records
int selectorPos[SCOREBOARD_MAX_PANELS]; // Posición del selector de letra para introducir el nombre
int score[SCOREBOARD_MAX_PANELS]; // Puntuación de los jugadores
float mult[SCOREBOARD_MAX_PANELS]; // Multiplicador de los jugadores
int continueCounter[SCOREBOARD_MAX_PANELS]; // Tiempo para continuar de los jugadores
int hiScore; // Máxima puntuación
float power; // Poder actual de la fase
std::string hiScoreName; // Nombre del jugador con la máxima puntuación
Color color; // Color del marcador
SDL_Rect rect; // Posición y dimensiones del marcador
panel_t panel[SCOREBOARD_MAX_PANELS]; // Lista con todos los paneles del marcador
Uint32 ticks; // Variable donde almacenar el valor de SDL_GetTiks()
int counter; // Contador
std::string name_[SCOREBOARD_MAX_PANELS]; // Nom de cada jugador
std::string record_name_[SCOREBOARD_MAX_PANELS]; // Nombre introducido para la tabla de records
int selector_pos_[SCOREBOARD_MAX_PANELS]; // Posición del selector de letra para introducir el nombre
int score_[SCOREBOARD_MAX_PANELS]; // Puntuación de los jugadores
float mult_[SCOREBOARD_MAX_PANELS]; // Multiplicador de los jugadores
int continue_counter_[SCOREBOARD_MAX_PANELS]; // Tiempo para continuar de los jugadores
Panel panel_[SCOREBOARD_MAX_PANELS]; // Lista con todos los paneles del marcador
int stage_; // Número de fase actual
int hi_score_; // Máxima puntuación
float power_; // Poder actual de la fase
std::string hi_score_name_; // Nombre del jugador con la máxima puntuación
Color color_; // Color del marcador
SDL_Rect rect_; // Posición y dimensiones del marcador
Uint32 ticks_; // Variable donde almacenar el valor de SDL_GetTiks()
int counter_; // Contador
// Puntos predefinidos para colocar elementos en los paneles
SDL_Point slot4_1, slot4_2, slot4_3, slot4_4;
SDL_Point enterNamePos;
SDL_Point slot4_1_, slot4_2_, slot4_3_, slot4_4_;
SDL_Point enter_name_pos_;
// Recalcula las anclas de los elementos
void recalculateAnchors();
@@ -128,7 +128,7 @@ public:
void setName(int panel, std::string name);
// Establece el valor de la variable
void setRecordName(int panel, std::string recordName);
void setRecordName(int panel, std::string record_name);
// Establece el valor de la variable
void setSelectorPos(int panel, int pos);
@@ -146,7 +146,7 @@ public:
void setStage(int stage);
// Establece el valor de la variable
void setHiScore(int hiScore);
void setHiScore(int hi_score);
// Establece el valor de la variable
void setPower(float power);

268
source/screen.cpp
View File

@@ -22,105 +22,101 @@
#endif
// [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
Screen *Screen::screen = nullptr;
Screen *Screen::screen_ = nullptr;
// [SINGLETON] Crearemos el objeto screen con esta función estática
void Screen::init(SDL_Window *window, SDL_Renderer *renderer)
{
Screen::screen = new Screen(window, renderer);
Screen::screen_ = new Screen(window, renderer);
}
// [SINGLETON] Destruiremos el objeto screen con esta función estática
void Screen::destroy()
{
delete Screen::screen;
delete Screen::screen_;
}
// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
Screen *Screen::get()
{
return Screen::screen;
return Screen::screen_;
}
// Constructor
Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
: window(window), renderer(renderer)
: window_(window), renderer_(renderer)
{
// Copia punteros
input = Input::get();
asset = Asset::get();
// Inicializa variables
srcrect = {0, 0, param.game.width, param.game.height};
dstrect = {0, 0, param.game.width, param.game.height};
borderColor = {0, 0, 0};
flashEffect.enabled = false;
flashEffect.counter = 0;
flashEffect.lenght = 0;
flashEffect.color = {0xFF, 0xFF, 0xFF};
shakeEffect.enabled = false;
shakeEffect.desp = 2;
shakeEffect.delay = 3;
shakeEffect.counter = 0;
shakeEffect.lenght = 8;
shakeEffect.remaining = 0;
shakeEffect.originalPos = 0;
shakeEffect.originalWidth = param.game.width;
attenuateEffect = false;
fpsTicks = 0;
fpsCounter = 0;
fps = 0;
src_rect_ = {0, 0, param.game.width, param.game.height};
dst_rect_ = {0, 0, param.game.width, param.game.height};
border_color_ = {0, 0, 0};
flash_effect_.enabled = false;
flash_effect_.counter = 0;
flash_effect_.lenght = 0;
flash_effect_.color = {0xFF, 0xFF, 0xFF};
shake_effect_.enabled = false;
shake_effect_.desp = 2;
shake_effect_.delay = 3;
shake_effect_.counter = 0;
shake_effect_.lenght = 8;
shake_effect_.remaining = 0;
shake_effect_.originalPos = 0;
shake_effect_.originalWidth = param.game.width;
attenuate_effect_ = false;
fps_ticks_ = 0;
fps_counter_ = 0;
fps_ = 0;
#ifdef DEBUG
showInfo = true;
show_info_ = true;
#else
showInfo = false;
show_info_ = false;
#endif
SDL_DisplayMode DM;
SDL_GetCurrentDisplayMode(0, &DM);
infoResolution = std::to_string(DM.w) + " X " + std::to_string(DM.h) + " AT " + std::to_string(DM.refresh_rate) + " HZ";
info_resolution_ = std::to_string(DM.w) + " X " + std::to_string(DM.h) + " AT " + std::to_string(DM.refresh_rate) + " HZ";
// Crea los objetos
notify = std::make_unique<Notify>(renderer, "", asset->get("8bithud.png"), asset->get("8bithud.txt"), asset->get("notify.wav"));
notify_ = std::make_unique<Notify>(renderer_, "", Asset::get()->get("8bithud.png"), Asset::get()->get("8bithud.txt"), Asset::get()->get("notify_.wav"));
// Define el color del borde para el modo de pantalla completa
borderColor = {0x00, 0x00, 0x00};
border_color_ = {0x00, 0x00, 0x00};
// Crea las textura donde se dibujan los graficos del juego
gameCanvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
shaderCanvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
game_canvas_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
shader_canvas_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
// Establece el modo de video
setVideoMode(options.video.mode);
// Muestra la ventana
SDL_ShowWindow(window);
SDL_ShowWindow(window_);
}
// Destructor
Screen::~Screen()
{
SDL_DestroyTexture(gameCanvas);
SDL_DestroyTexture(shaderCanvas);
SDL_DestroyTexture(game_canvas_);
SDL_DestroyTexture(shader_canvas_);
}
// Limpia la pantalla
void Screen::clean(Color color)
{
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
SDL_RenderClear(renderer_);
}
// Prepara para empezar a dibujar en la textura de juego
void Screen::start()
{
SDL_SetRenderTarget(renderer, gameCanvas);
SDL_SetRenderTarget(renderer_, game_canvas_);
}
// Vuelca el contenido del renderizador en pantalla
void Screen::blit()
{
// Actualiza el contador de FPS
fpsCounter++;
fps_counter_++;
// Actualiza y dibuja el efecto de flash en la pantalla
doFlash();
@@ -135,51 +131,51 @@ void Screen::blit()
displayInfo();
// Muestra las notificaciones
notify->render();
notify_->render();
#ifdef NO_SHADERS
// Vuelve a dejar el renderizador en modo normal
SDL_SetRenderTarget(renderer, nullptr);
SDL_SetRenderTarget(renderer_, nullptr);
// Borra el contenido previo
SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, border_color_.r, border_color_.g, border_color_.b, 0xFF);
SDL_RenderClear(renderer_);
// Copia la textura de juego en el renderizador en la posición adecuada
if (shakeEffect.enabled)
SDL_RenderCopy(renderer, gameCanvas, nullptr, nullptr);
SDL_RenderCopy(renderer, gameCanvas, &srcrect, &dstrect);
if (shake_effect_.enabled)
SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
// Muestra por pantalla el renderizador
SDL_RenderPresent(renderer);
SDL_RenderPresent(renderer_);
#else
if (options.video.shaders)
{
SDL_SetRenderTarget(renderer, shaderCanvas);
SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xFF);
SDL_RenderClear(renderer);
if (shakeEffect.enabled)
SDL_RenderCopy(renderer, gameCanvas, nullptr, nullptr);
SDL_RenderCopy(renderer, gameCanvas, &srcrect, &dstrect);
SDL_SetRenderTarget(renderer, nullptr);
SDL_SetRenderTarget(renderer_, shader_canvas_);
SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
SDL_RenderClear(renderer_);
if (shake_effect_.enabled)
SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
SDL_SetRenderTarget(renderer_, nullptr);
shader::render();
}
else
{
// Vuelve a dejar el renderizador en modo normal
SDL_SetRenderTarget(renderer, nullptr);
SDL_SetRenderTarget(renderer_, nullptr);
// Borra el render
SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xFF);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
SDL_RenderClear(renderer_);
// Copia la textura de juego en el renderizador en la posición adecuada
if (shakeEffect.enabled)
SDL_RenderCopy(renderer, gameCanvas, nullptr, nullptr);
SDL_RenderCopy(renderer, gameCanvas, &srcrect, &dstrect);
if (shake_effect_.enabled)
SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
// Muestra por pantalla el renderizador
SDL_RenderPresent(renderer);
SDL_RenderPresent(renderer_);
}
#endif
}
@@ -197,7 +193,7 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
case ScreenVideoMode::WINDOW:
{
// Cambia a modo de ventana
SDL_SetWindowFullscreen(window, 0);
SDL_SetWindowFullscreen(window_, 0);
#ifdef ARCADE
// Oculta el puntero
@@ -207,8 +203,8 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
SDL_ShowCursor(SDL_ENABLE);
#endif
// Modifica el tamaño de la ventana
SDL_SetWindowSize(window, param.game.width * options.video.window.size, param.game.height * options.video.window.size);
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
SDL_SetWindowSize(window_, param.game.width * options.video.window.size, param.game.height * options.video.window.size);
SDL_SetWindowPosition(window_, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
break;
}
@@ -217,7 +213,7 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
case ScreenVideoMode::FULLSCREEN:
{
// Aplica el modo de video
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
SDL_SetWindowFullscreen(window_, SDL_WINDOW_FULLSCREEN_DESKTOP);
// Oculta el puntero
SDL_ShowCursor(SDL_DISABLE);
@@ -233,10 +229,10 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
if (options.video.shaders)
{
#ifndef NO_SHADERS
std::ifstream f(asset->get("crtpi.glsl").c_str());
std::ifstream f(Asset::get()->get("crtpi.glsl").c_str());
std::string source((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
shader::init(window, shaderCanvas, source.c_str());
shader::init(window_, shader_canvas_, source.c_str());
#endif
}
}
@@ -274,20 +270,20 @@ void Screen::incWindowSize()
// Cambia el color del borde
void Screen::setBorderColor(Color color)
{
borderColor = color;
border_color_ = color;
}
// Cambia el tipo de mezcla
void Screen::setBlendMode(SDL_BlendMode blendMode)
{
SDL_SetRenderDrawBlendMode(renderer, blendMode);
SDL_SetRenderDrawBlendMode(renderer_, blendMode);
}
// Actualiza la lógica de la clase
void Screen::update()
{
updateShake();
notify->update();
updateShakeEffect();
notify_->update();
updateFPS();
OnScreenHelp::get()->update();
}
@@ -297,7 +293,7 @@ void Screen::checkInput()
{
#ifndef ARCADE
// Comprueba el teclado para cambiar entre pantalla completa y ventana
if (input->checkInput(input_window_fullscreen, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
if (Input::get()->checkInput(input_window_fullscreen, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
{
switchVideoMode();
const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen";
@@ -306,7 +302,7 @@ void Screen::checkInput()
}
// Comprueba el teclado para decrementar el tamaño de la ventana
if (input->checkInput(input_window_dec_size, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
if (Input::get()->checkInput(input_window_dec_size, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
{
decWindowSize();
const std::string size = std::to_string(options.video.window.size);
@@ -315,7 +311,7 @@ void Screen::checkInput()
}
// Comprueba el teclado para incrementar el tamaño de la ventana
if (input->checkInput(input_window_inc_size, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
if (Input::get()->checkInput(input_window_inc_size, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
{
incWindowSize();
const std::string size = std::to_string(options.video.window.size);
@@ -325,7 +321,7 @@ void Screen::checkInput()
#endif
// Comprueba el teclado para activar o desactivar los shaders
if (input->checkInput(input_video_shaders, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
if (Input::get()->checkInput(input_video_shaders, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
{
switchShaders();
return;
@@ -333,26 +329,26 @@ void Screen::checkInput()
#ifdef DEBUG
// Comprueba el teclado para mostrar la información de debug
if (input->checkInput(input_showinfo, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
if (Input::get()->checkInput(input_showinfo, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
{
showInfo = !showInfo;
show_info_ = !show_info_;
return;
}
#endif
for (int i = 0; i < input->getNumControllers(); ++i)
for (int i = 0; i < Input::get()->getNumControllers(); ++i)
{
// Comprueba los mandos para activar o desactivar los shaders
if (input->checkModInput(input_service, input_video_shaders, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
if (Input::get()->checkModInput(input_service, input_video_shaders, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
{
switchShaders();
return;
}
// Comprueba los mandos para mostrar la información de debug
if (input->checkModInput(input_service, input_showinfo, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
if (Input::get()->checkModInput(input_service, input_showinfo, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
{
showInfo = !showInfo;
show_info_ = !show_info_;
return;
}
}
@@ -362,43 +358,43 @@ void Screen::checkInput()
void Screen::shake()
{
// Si no hay un shake effect activo, se guarda una copia de los valores actuales antes de modificarlos
if (!shakeEffect.enabled)
if (!shake_effect_.enabled)
{
shakeEffect.enabled = true;
shakeEffect.originalPos = srcrect.x;
shakeEffect.originalWidth = srcrect.w;
srcrect.w -= shakeEffect.desp;
dstrect.w = srcrect.w;
shake_effect_.enabled = true;
shake_effect_.originalPos = src_rect_.x;
shake_effect_.originalWidth = src_rect_.w;
src_rect_.w -= shake_effect_.desp;
dst_rect_.w = src_rect_.w;
}
// Si ya hay un shake effect en marcha no se pilla el origen, solo se renuevan los contadores
shakeEffect.remaining = shakeEffect.lenght;
shakeEffect.counter = shakeEffect.delay;
shake_effect_.remaining = shake_effect_.lenght;
shake_effect_.counter = shake_effect_.delay;
}
// Actualiza la logica para agitar la pantalla
void Screen::updateShake()
void Screen::updateShakeEffect()
{
if (shakeEffect.enabled)
if (shake_effect_.enabled)
{
if (shakeEffect.counter > 0)
if (shake_effect_.counter > 0)
{
shakeEffect.counter--;
shake_effect_.counter--;
}
else
{
shakeEffect.counter = shakeEffect.delay;
const auto srcdesp = shakeEffect.remaining % 2 == 0 ? 0 : shakeEffect.desp;
const auto dstdesp = shakeEffect.remaining % 2 == 1 ? 0 : shakeEffect.desp;
srcrect.x = shakeEffect.originalPos + srcdesp;
dstrect.x = shakeEffect.originalPos + dstdesp;
shakeEffect.remaining--;
shakeEffect.enabled = shakeEffect.remaining == -1 ? false : true;
if (!shakeEffect.enabled)
shake_effect_.counter = shake_effect_.delay;
const auto srcdesp = shake_effect_.remaining % 2 == 0 ? 0 : shake_effect_.desp;
const auto dstdesp = shake_effect_.remaining % 2 == 1 ? 0 : shake_effect_.desp;
src_rect_.x = shake_effect_.originalPos + srcdesp;
dst_rect_.x = shake_effect_.originalPos + dstdesp;
shake_effect_.remaining--;
shake_effect_.enabled = shake_effect_.remaining == -1 ? false : true;
if (!shake_effect_.enabled)
{
srcrect.x = shakeEffect.originalPos;
srcrect.w = shakeEffect.originalWidth;
dstrect = srcrect;
src_rect_.x = shake_effect_.originalPos;
src_rect_.w = shake_effect_.originalWidth;
dst_rect_ = src_rect_;
}
}
}
@@ -407,39 +403,39 @@ void Screen::updateShake()
// Pone la pantalla de color
void Screen::flash(Color color, int lenght)
{
flashEffect.enabled = true;
flashEffect.counter = 0;
flashEffect.lenght = lenght;
flashEffect.color = color;
flash_effect_.enabled = true;
flash_effect_.counter = 0;
flash_effect_.lenght = lenght;
flash_effect_.color = color;
}
// Actualiza y dibuja el efecto de flash en la pantalla
void Screen::doFlash()
{
if (flashEffect.enabled)
if (flash_effect_.enabled)
{
// Dibuja el color del flash en la textura
SDL_Texture *temp = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, gameCanvas);
SDL_SetRenderDrawColor(renderer, flashEffect.color.r, flashEffect.color.g, flashEffect.color.b, 0xFF);
SDL_RenderClear(renderer);
SDL_SetRenderTarget(renderer, temp);
SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
SDL_SetRenderTarget(renderer_, game_canvas_);
SDL_SetRenderDrawColor(renderer_, flash_effect_.color.r, flash_effect_.color.g, flash_effect_.color.b, 0xFF);
SDL_RenderClear(renderer_);
SDL_SetRenderTarget(renderer_, temp);
// Actualiza la lógica del efecto
flashEffect.counter < flashEffect.lenght ? flashEffect.counter++ : flashEffect.enabled = false;
flash_effect_.counter < flash_effect_.lenght ? flash_effect_.counter++ : flash_effect_.enabled = false;
}
}
// Atenua la pantalla
void Screen::doAttenuate()
{
if (attenuateEffect)
if (attenuate_effect_)
{
SDL_Texture *temp = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, gameCanvas);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 64);
SDL_RenderFillRect(renderer, nullptr);
SDL_SetRenderTarget(renderer, temp);
SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
SDL_SetRenderTarget(renderer_, game_canvas_);
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 64);
SDL_RenderFillRect(renderer_, nullptr);
SDL_SetRenderTarget(renderer_, temp);
}
}
@@ -455,50 +451,50 @@ void Screen::switchShaders()
// Atenua la pantalla
void Screen::attenuate(bool value)
{
attenuateEffect = value;
attenuate_effect_ = value;
}
// Muestra una notificación de texto por pantalla;
void Screen::showNotification(std::string text1, std::string text2, int icon)
{
notify->showText(text1, text2, icon);
notify_->showText(text1, text2, icon);
}
// Obtiene el puntero al renderizador
SDL_Renderer *Screen::getRenderer()
{
return renderer;
return renderer_;
}
// Calcula los frames por segundo
void Screen::updateFPS()
{
if (SDL_GetTicks() - fpsTicks > 1000)
if (SDL_GetTicks() - fps_ticks_ > 1000)
{
fpsTicks = SDL_GetTicks();
fps = fpsCounter;
fpsCounter = 0;
fps_ticks_ = SDL_GetTicks();
fps_ = fps_counter_;
fps_counter_ = 0;
}
}
// Muestra información por pantalla
void Screen::displayInfo()
{
if (showInfo)
if (show_info_)
{
// FPS
const std::string fpstext = std::to_string(fps) + " FPS";
const std::string fpstext = std::to_string(fps_) + " FPS";
dbg_print(param.game.width - fpstext.length() * 8, 0, fpstext.c_str(), 255, 255, 0);
// Resolution
dbg_print(0, 0, infoResolution.c_str(), 255, 255, 0);
dbg_print(0, 0, info_resolution_.c_str(), 255, 255, 0);
dbg_print(0, 8, std::to_string(globalInputs::servicePressedCounter[0]).c_str(), 255, 255, 0);
}
}
// Indica si hay alguna notificación activa en pantalla
bool Screen::notificationsAreActive()
bool Screen::notificationsAreActive() const
{
return notify->active();
return notify_->active();
}

59
source/screen.h
View File

@@ -8,17 +8,15 @@
#include <string> // for basic_string, string
#include "utils.h" // for Color
#include <memory>
class Asset;
class Input;
class Notify;
enum class ScreenFilter
enum class ScreenFilter : int
{
NEAREST = 0,
LINEAL = 1,
};
enum class ScreenVideoMode
enum class ScreenVideoMode : int
{
WINDOW = 0,
FULLSCREEN = 1,
@@ -28,29 +26,27 @@ class Screen
{
private:
// [SINGLETON] Objeto screen privado para Don Melitón
static Screen *screen;
static Screen *screen_;
// Objetos y punteros
SDL_Window *window; // Ventana de la aplicación
SDL_Renderer *renderer; // El renderizador de la ventana
Asset *asset; // Objeto con el listado de recursos
Input *input; // Objeto para leer las entradas de teclado o mando
std::unique_ptr<Notify> notify; // Pinta notificaciones en pantalla
SDL_Texture *gameCanvas; // Textura donde se dibuja todo antes de volcarse al renderizador
SDL_Texture *shaderCanvas; // Textura para pasarle al shader desde gameCanvas
SDL_Window *window_; // Ventana de la aplicación
SDL_Renderer *renderer_; // El renderizador de la ventana
std::unique_ptr<Notify> notify_; // Pinta notificaciones en pantalla
SDL_Texture *game_canvas_; // Textura donde se dibuja todo antes de volcarse al renderizador
SDL_Texture *shader_canvas_; // Textura para pasarle al shader desde gameCanvas
// Variables
SDL_Rect srcrect; // Coordenadas de donde va a pillar la textura del juego para dibujarla
SDL_Rect dstrect; // Coordenadas donde se va a dibujar la textura del juego sobre la pantalla o ventana
Color borderColor; // Color del borde añadido a la textura de juego para rellenar la pantalla
bool attenuateEffect; // Indica si la pantalla ha de estar atenuada
Uint32 fpsTicks; // Ticks para contar los frames por segundo
int fpsCounter; // Contador de frames por segundo
int fps; // Frames calculados en el último segundo
bool showInfo; // Indica si ha de mostrar/ocultar la información de la pantalla
std::string infoResolution; // Texto con la informacion de la pantalla
SDL_Rect src_rect_; // Coordenadas de donde va a pillar la textura del juego para dibujarla
SDL_Rect dst_rect_; // Coordenadas donde se va a dibujar la textura del juego sobre la pantalla o ventana
Color border_color_; // Color del borde añadido a la textura de juego para rellenar la pantalla
bool attenuate_effect_; // Indica si la pantalla ha de estar atenuada
Uint32 fps_ticks_; // Ticks para contar los frames por segundo
int fps_counter_; // Contador de frames por segundo
int fps_; // Frames calculados en el último segundo
bool show_info_; // Indica si ha de mostrar/ocultar la información de la pantalla
std::string info_resolution_; // Texto con la informacion de la pantalla
struct effect_t
struct FlashEffect
{
bool enabled; // Indica si el efecto está activo
int counter; // Contador para el efecto
@@ -58,10 +54,7 @@ private:
Color color; // Color del efecto
};
// Variables - Efectos
effect_t flashEffect; // Variable para gestionar el efecto de flash
struct shake_t
struct ShakeEffect
{
int desp; // Pixels de desplazamiento para agitar la pantalla en el eje x
int delay; // Retraso entre cada desplazamiento de la pantalla al agitarse
@@ -71,10 +64,14 @@ private:
int originalPos; // Posición inicial de la pantalla para dejarla igual tras el desplazamiento
int originalWidth; // Anchura inicial de la pantalla para dejarla igual tras el desplazamiento
bool enabled; // Indica si el efecto está activo
} shakeEffect;
};
// Variables - Efectos
FlashEffect flash_effect_; // Variable para gestionar el efecto de flash
ShakeEffect shake_effect_; // Variable para gestionar el efecto de agitar la pantalla
// Actualiza la logica para agitar la pantalla
void updateShake();
void updateShakeEffect();
// Actualiza y dibuja el efecto de flash en la pantalla
void doFlash();
@@ -122,7 +119,7 @@ public:
void blit();
// Establece el modo de video
void setVideoMode(ScreenVideoMode videoMode);
void setVideoMode(ScreenVideoMode video_mode);
// Camibia entre pantalla completa y ventana
void switchVideoMode();
@@ -140,7 +137,7 @@ public:
void setBorderColor(Color color);
// Cambia el tipo de mezcla
void setBlendMode(SDL_BlendMode blendMode);
void setBlendMode(SDL_BlendMode blend_mode);
// Agita la pantalla
void shake();
@@ -158,7 +155,7 @@ public:
void showNotification(std::string text1 = "", std::string text2 = "", int icon = -1);
// Indica si hay alguna notificación activa en pantalla
bool notificationsAreActive();
bool notificationsAreActive() const;
// Obtiene el puntero al renderizador
SDL_Renderer *getRenderer();