305 lines
7.5 KiB
C++
305 lines
7.5 KiB
C++
#include "scoreboard.h"
|
|
|
|
// Constructor
|
|
Scoreboard::Scoreboard(SDL_Renderer *renderer, Screen *screen, Asset *asset, Lang *lang, options_t *options)
|
|
{
|
|
// Copia los punteros
|
|
this->renderer = renderer;
|
|
this->screen = screen;
|
|
this->asset = asset;
|
|
this->lang = lang;
|
|
this->options = options;
|
|
|
|
// Inicializa variables
|
|
stage = 1;
|
|
score1 = 0;
|
|
score2 = 0;
|
|
mult1 = 1;
|
|
mult2 = 1;
|
|
hiScore = 0;
|
|
power = 0;
|
|
hiScoreName = "";
|
|
color = {0, 0, 0};
|
|
rect = {0, 0, 320, 40};
|
|
mode[0] = SCOREBOARD_MODE_PLAYING;
|
|
mode[1] = SCOREBOARD_MODE_PLAYING;
|
|
ticks = SDL_GetTicks();
|
|
counter = 0;
|
|
|
|
// Recalcula las anclas de los elementos
|
|
recalculateAnchors();
|
|
|
|
// Crea objetos
|
|
gamePowerMeterTexture = new Texture(renderer, asset->get("game_power_meter.png"));
|
|
powerMeterSprite = new Sprite(offsetPowerMeter.x - 20, offsetPowerMeter.y, 40, 7, gamePowerMeterTexture, renderer);
|
|
textScoreBoard = new Text(asset->get("8bithud.png"), asset->get("8bithud.txt"), renderer);
|
|
|
|
// Crea la textura para dibujar el marcador
|
|
background = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
|
|
SDL_SetTextureBlendMode(background, SDL_BLENDMODE_BLEND);
|
|
|
|
// Rellena la textura de fondo
|
|
fillBackgroundTexture();
|
|
}
|
|
|
|
Scoreboard::~Scoreboard()
|
|
{
|
|
gamePowerMeterTexture->unload();
|
|
delete gamePowerMeterTexture;
|
|
delete powerMeterSprite;
|
|
delete textScoreBoard;
|
|
SDL_DestroyTexture(background);
|
|
}
|
|
|
|
// Transforma un valor numérico en una cadena de 6 cifras
|
|
std::string Scoreboard::updateScoreText(Uint32 num)
|
|
{
|
|
if ((num >= 0) && (num <= 9))
|
|
{
|
|
return ("000000" + std::to_string(num));
|
|
}
|
|
|
|
if ((num >= 10) && (num <= 99))
|
|
{
|
|
return ("00000" + std::to_string(num));
|
|
}
|
|
|
|
if ((num >= 100) && (num <= 999))
|
|
{
|
|
return ("0000" + std::to_string(num));
|
|
}
|
|
|
|
if ((num >= 1000) && (num <= 9999))
|
|
{
|
|
return ("000" + std::to_string(num));
|
|
}
|
|
|
|
if ((num >= 010000) && (num <= 99999))
|
|
{
|
|
return ("00" + std::to_string(num));
|
|
}
|
|
|
|
if ((num >= 100000) && (num <= 999999))
|
|
{
|
|
return ("0" + std::to_string(num));
|
|
}
|
|
|
|
if ((num >= 1000000) && (num <= 9999999))
|
|
{
|
|
return (std::to_string(num));
|
|
}
|
|
|
|
return (std::to_string(num));
|
|
}
|
|
|
|
// Actualiza el contador
|
|
void Scoreboard::updateCounter()
|
|
{
|
|
if (SDL_GetTicks() - ticks > SCOREBOARD_TICK_SPEED)
|
|
{
|
|
ticks = SDL_GetTicks();
|
|
counter++;
|
|
}
|
|
}
|
|
|
|
// Actualiza la lógica del marcador
|
|
void Scoreboard::update()
|
|
{
|
|
fillBackgroundTexture();
|
|
updateCounter();
|
|
}
|
|
|
|
// Pinta el marcador
|
|
void Scoreboard::render()
|
|
{
|
|
SDL_RenderCopy(renderer, background, nullptr, &rect);
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void Scoreboard::setScore1(int score)
|
|
{
|
|
score1 = score;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void Scoreboard::setScore2(int score)
|
|
{
|
|
score2 = score;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void Scoreboard::setMult1(float mult)
|
|
{
|
|
mult1 = mult;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void Scoreboard::setMult2(float mult)
|
|
{
|
|
mult2 = mult;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void Scoreboard::setStage(int stage)
|
|
{
|
|
this->stage = stage;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void Scoreboard::setHiScore(int hiScore)
|
|
{
|
|
this->hiScore = hiScore;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void Scoreboard::setPower(float power)
|
|
{
|
|
this->power = power;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void Scoreboard::setHiScoreName(std::string name)
|
|
{
|
|
hiScoreName = name;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void Scoreboard::setColor(color_t color)
|
|
{
|
|
this->color = color;
|
|
fillBackgroundTexture();
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void Scoreboard::setPos(SDL_Rect rect)
|
|
{
|
|
this->rect = rect;
|
|
|
|
// Recalcula las anclas de los elementos
|
|
recalculateAnchors();
|
|
|
|
powerMeterSprite->setPosX(offsetPowerMeter.x - 20);
|
|
powerMeterSprite->setPosY(offsetPowerMeter.y);
|
|
|
|
// Recrea la textura de fondo
|
|
if (background)
|
|
{
|
|
SDL_DestroyTexture(background);
|
|
}
|
|
background = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
|
|
SDL_SetTextureBlendMode(background, SDL_BLENDMODE_BLEND);
|
|
fillBackgroundTexture();
|
|
}
|
|
|
|
// Rellena la textura de fondo
|
|
void Scoreboard::fillBackgroundTexture()
|
|
{
|
|
// Cambia el destino del renderizador
|
|
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_RenderFillRect(renderer, nullptr);
|
|
|
|
// PARTE IZQUIERDA
|
|
if (mode[SCOREBOARD_LEFT_SIDE] == SCOREBOARD_MODE_PLAYING)
|
|
{ // PLAYER1 - SCORE
|
|
textScoreBoard->writeCentered(offsetScoreP1Label.x, offsetScoreP1Label.y, lang->getText(53));
|
|
textScoreBoard->writeCentered(offsetScoreP1.x, offsetScoreP1.y, updateScoreText(score1));
|
|
|
|
// PLAYER1 - MULT
|
|
textScoreBoard->writeCentered(offsetMultP1Label.x, offsetMultP1Label.y, lang->getText(55));
|
|
textScoreBoard->writeCentered(offsetMultP1.x, offsetMultP1.y, std::to_string(mult1).substr(0, 3));
|
|
}
|
|
|
|
else if (mode[SCOREBOARD_LEFT_SIDE] == SCOREBOARD_MODE_DEMO)
|
|
{
|
|
if (counter % 2 == 0)
|
|
{
|
|
textScoreBoard->writeCentered(offsetScoreP1.x, offsetScoreP1.y, "Mode");
|
|
textScoreBoard->writeCentered(offsetMultP1Label.x, offsetMultP1Label.y, "Demo");
|
|
}
|
|
}
|
|
|
|
// PARTE DERECHA
|
|
if (mode[SCOREBOARD_RIGHT_SIDE] == SCOREBOARD_MODE_PLAYING)
|
|
{ // PLAYER2 - SCORE
|
|
textScoreBoard->writeCentered(offsetScoreP2Label.x, offsetScoreP2Label.y, lang->getText(54));
|
|
textScoreBoard->writeCentered(offsetScoreP2.x, offsetScoreP2.y, updateScoreText(score2));
|
|
|
|
// PLAYER2 - MULT
|
|
textScoreBoard->writeCentered(offsetMultP2Label.x, offsetMultP2Label.y, lang->getText(55));
|
|
textScoreBoard->writeCentered(offsetMultP2.x, offsetMultP2.y, std::to_string(mult2).substr(0, 3));
|
|
}
|
|
|
|
else if (mode[SCOREBOARD_RIGHT_SIDE] == SCOREBOARD_MODE_DEMO)
|
|
{
|
|
if (counter % 2 == 0)
|
|
{
|
|
textScoreBoard->writeCentered(offsetScoreP2.x, offsetScoreP2.y, "Mode");
|
|
textScoreBoard->writeCentered(offsetMultP2Label.x, offsetMultP2Label.y, "Demo");
|
|
}
|
|
}
|
|
|
|
// PARTE CENTRAL
|
|
|
|
// STAGE
|
|
textScoreBoard->writeCentered(offsetStage.x, offsetStage.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();
|
|
|
|
// HI-SCORE
|
|
textScoreBoard->writeCentered(offsetHiScoreLabel.x, offsetHiScoreLabel.y, lang->getText(56));
|
|
textScoreBoard->writeCentered(offsetHiScore.x, offsetHiScore.y, hiScoreName + updateScoreText(hiScore));
|
|
|
|
// Deja el renderizador apuntando donde estaba
|
|
SDL_SetRenderTarget(renderer, temp);
|
|
}
|
|
|
|
// Recalcula las anclas de los elementos
|
|
void Scoreboard::recalculateAnchors()
|
|
{
|
|
// Constantes para definir las zonas del marcador: 4 filas y 3 columnas
|
|
const int rowSize = rect.h / 4;
|
|
const int textHeight = 7;
|
|
const int row1 = (rowSize * 0) + (textHeight / 2);
|
|
const int row2 = (rowSize * 1) + (textHeight / 2) - 1;
|
|
const int row3 = (rowSize * 2) + (textHeight / 2) - 2;
|
|
const int row4 = (rowSize * 3) + (textHeight / 2) - 3;
|
|
|
|
const int halfColSize = rect.w / 6;
|
|
const int col1 = halfColSize;
|
|
const int col2 = halfColSize * 3;
|
|
const int col3 = halfColSize * 5;
|
|
|
|
// Primera fila
|
|
offsetScoreP1Label = {col1, row1};
|
|
offsetStage = {col2, row1};
|
|
offsetScoreP2Label = {col3, row1};
|
|
|
|
// Segunda fila
|
|
offsetScoreP1 = {col1, row2};
|
|
offsetPowerMeter = {col2, row2};
|
|
offsetScoreP2 = {col3, row2};
|
|
|
|
// Tercera fila
|
|
offsetMultP1Label = {col1, row3};
|
|
offsetHiScoreLabel = {col2, row3};
|
|
offsetMultP2Label = {col3, row3};
|
|
|
|
// Cuarta fila
|
|
offsetMultP1 = {col1, row4};
|
|
offsetHiScore = {col2, row4};
|
|
offsetMultP2 = {col3, row4};
|
|
}
|
|
|
|
// Establece el modo del marcador
|
|
void Scoreboard::setMode(int index, scoreboard_modes_e mode)
|
|
{
|
|
this->mode[index] = mode;
|
|
} |